Scala Cookbook读书笔记 Chapter 3.Control Structures 第一部分

3.0 总体介绍

Scala中的if/then/else结构和Java中很像，但是它还可以用来返回一个值。比如Java中用的三目运算，在Scala中只需要使用正常的if语句即可。

val x = if (a) y else z

try/catch/finilly结构和Java中很像，但是Scala中的catch部分使用的是模式匹配。

Scala中可以使用2个for循环读取文件的每行，然后在每行上操作每个字符：

for (line <- source.getLines) {
for {
char <- line
if char.isLetter
} // char algorithm here ...
}

在Scala中，还可以更加简单点：

for {
line <- source.getLines
char <- line
if char.isLetter
} // char algorithm here ...

Scala很容易对一个集合进行操作并产生一个新的集合：

scala> val nieces = List("emily", "hannah", "mercedes", "porsche")
nieces: List[String] = List(emily, hannah, mercedes, porsche)

scala> for (n <- nieces) yield n.capitalize
res0: List[String] = List(Emily, Hannah, Mercedes, Porsche)

类似的，基本用法中Scala的匹配表达式和Java的Switch语句很像，但是匹配模式可以匹配任何对象，从匹配的对象中提取信息，添加case分支，返回结果而且更多。匹配表达式是Scala语言的一大特色。

3.1 使用for和foreach循环

问题：想要遍历集合中的元素，或者操作集合中的每个元素，或者根据已有集合创建一个新集合。

3.1.1 解决方案

有很多循环Scala集合的方法，包括for循环，while循环，foreach、map、flatMap等集合方法。该方案主要针对for循环和foreach方法。

val a = Array("apple", "banana", "orange")

//for循环
scala> for (e <- a) println(e)
apple
banana
orange

多行数据处理，使用for循环，并且类代码块里执行

scala> for (e <- a) {
| // imagine this requires multiple lines
| val s = e.toUpperCase
| println(s)
| }
APPLE
BANANA
ORANGE

3.1.2 for循环返回值

使用for/yield组合根据输入集合创建一个新的集合：

scala> val newArray = for (e <- a) yield e.toUpperCase
newArray: Array[java.lang.String] = Array(APPLE, BANANA, ORANGE)

注意输入类型是Array，输出也是Array，而不是其他比如Vector

在yield关键词后使用代码块处理多行代码：

scala> val newArray = for (e <- a) yield {
| // imagine this requires multiple lines
| val s = e.toUpperCase
| s
| }
newArray: Array[java.lang.String] = Array(APPLE, BANANA, ORANGE)

3.1.3 for循环计数器

使用计数器获取数组元素

for (i <- 0 until a.length) {
println(s"$i is ${a(i)}")
}

//输出
0 is apple
1 is banana
2 is orange

使用zipWithIndex方法创建一个循环计数器

scala> for ((e, count) <- a.zipWithIndex) {
| println(s"$count is $e")
| }
0 is apple
1 is banana
2 is orange

更多zipWithIndex看10.11章

3.1.4 生成

使用Range执行3次for循环

scala> for (i <- 1 to 3) println(i)
1
2
3

使用1 to 3创建一个Range

scala> 1 to 3
res0: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3)

章节3.3演示如何使用guards，这里简单预览下：

scala> for (i <- 1 to 10 if i < 4) println(i)
1
2
3

3.1.5 Map的循环

当循环Map里的键和值时，下面循环方法简明可读：

val names = Map("fname" -> "Robert",
"lname" -> "Goren")
for ((k,v) <- names) println(s"key: $k, value: $v")

更多查看11.17章

3.1.6 讨论

for/yield组合是创建并返回一个新集合。但是没有yield的for循环只是操作集合中的每个元素，并没有创建一个新集合。for/yield组合基本使用就像map方法一样。更多看3.4章

for循环并不一定是最好的解决问题的方法。foreach,map，flatMap，collect，reduce等等方法经常被用来解决问题，而不要求使用for循环。

可以通过foreach循环每个元素

scala> a.foreach(println)
apple
banana
orange

需要在集合每个元素上进行数据处理，使用匿名函数语法：

scala> a.foreach(e => println(e.toUpperCase))
APPLE
BANANA
ORANGE

需要多行数据处理，使用代码块

scala> a.foreach { e =>
| val s = e.toUpperCase
| println(s)
| }
APPLE
BANANA
ORANGE

3.1.7 for循环如何被翻译

Scala Language Specification 提供了在不同环境for循环被翻译的精确细节。可以总结为以下四点：

简单for循环被翻译成集合上的foreach方法调用

使用guard（3.3章）的for循环被翻译成集合上使用withFilter方法的序列，后面跟着foreach调用

for/yield组合表达式被翻译成集合上的map方法调用

for/yield/guard组合被翻译成集合上使用withFilter方法，后面跟着map调用

使用下面的scalac命令行提供Scala编译器翻译for循环为其他代码的初始化输出：

$ scalac -Xprint:parse Main.scala

在一个命名为Main.scala的文件中写以下代码

class Main {
for (i <- 1 to 10) println(i)
}

使用scalac命令行后输出如下

$ scalac -Xprint:parse Main.scala
[[syntax trees at end of parser]] // Main.scala
package <empty> {
class Main extends scala.AnyRef {
def <init>() = {
super.<init>();
()
};
1.to(10).foreach(((i) => println(i)))
}
}

如果使用 -Xprint:all 选项代替 -Xprint:parse 编译文件，会发现代码进一步被被翻译成下面的代码,包括太多编译时的细节：

$ scalac -Xprint:all Main.scala

scala.this.Predef.intWrapper(1).to(10).foreach[Unit]
(((i: Int) => scala.this.Predef.println(i)))

上面使用的是Range，但是在其他集合编译器表现一样。下例使用list代替Range：

// original List code
val nums = List(1,2,3)
for (i <- nums) println(i)

// translation performed by the compiler
val nums = List(1,2,3)
nums.foreach(((i) => println(i)))

下面演示各种for循环如何被翻译：

第一个代码

// #1 - input (my code)
for (i <- 1 to 10) println(i)

// #1 - compiler output
1.to(10).foreach(((i) => println(i)))

添加guard(if语句)

// #2 - input code
for {
i <- 1 to 10
if i % 2 == 0
} println(i)

// #2 - translated output
1.to(10).withFilter(((i) => i.$percent(2).$eq$eq(0))).foreach(((i) =>
println(i)))

两个guard被翻译成两个withFilter调用

// #3 - input code
for {
i <- 1 to 10
if i != 1
if i % 2 == 0
} println(i)

// #3 - translated output
1.to(10).withFilter(((i) => i.$bang$eq(1)))
.withFilter(((i)
=> i.$percent(2).$eq$eq(0))).foreach(((i) => println(i)))

for/yield组合

// #4 - input code
for { i <- 1 to 10 } yield i

// #4 - output
1.to(10).map(((i) => i))

for/yield/guard组合

// #5 - input code (for loop, guard, and yield)
for {
i <- 1 to 10
if i % 2 == 0
} yield i

// #5 - translated code
1.to(10).withFilter(((i) => i.$percent(2).$eq$eq(0))).map(((i) => i))

3.2 使用多个计数器的for循环

问题：当你循环多维数组时，需要创建一个带有多个计数器的循环。

3.2.1 解决方案

如下方法创建：

scala> for (i <- 1 to 2; j <- 1 to 2) println(s"i = $i, j = $j")
i = 1, j = 1
i = 1, j = 2
i = 2, j = 1
i = 2, j = 2

对于多行for循环首选的格式是花括号：

for {
i <- 1 to 2
j <- 1 to 2
} println(s"i = $i, j = $j")

三个计数器：

for {
i <- 1 to 3
j <- 1 to 5
k <- 1 to 10
} println(s"i = $i, j = $j, k = $k")

当循环多维数组时非常有用，假设创建一个二维数组：

val array = Array.ofDim[Int](2,2)
array(0)(0) = 0
array(0)(1) = 1
array(1)(0) = 2
array(1)(1) = 3

通过以下方式打印数组的每个元素：

scala> for {
| i <- 0 to 1
| j <- 0 to 1
| } println(s"($i)($j) = ${array(i)(j)}")
(0)(0) = 0
(0)(1) = 1
(1)(0) = 2
(1)(1) = 3

3.2.2 讨论

在for循环里使用符号<-创建的Range指的是生成器，可以在一个循环里使用多个生成器。

较长for循环里推荐格式是使用大括号：

for {

i <- 1 to 2

j <- 2 to 3

} println(s”i = i,j=j”)

这种格式比其他格式可扩展性高，这里指的是在表达式里添加更多生成器和guards后依旧可读性高

查看更多

Scala Style Guide page on formatting control

3.3 使用加入if语句的for循环

问题：想要在for循环添加一个或者更多条件语句用来过滤掉集合中的某些元素。

3.3.1 解决方案

在生成器后添加if语句

// print all even numbers
scala> for (i <- 1 to 10 if i % 2 == 0) println(i)
2
4
6
8
10

或者使用大括号格式：

for {
i <- 1 to 10
if i % 2 == 0
} println(i)

使用多个if语句

for {
i <- 1 to 10
if i > 3
if i < 6
if i % 2 == 0
} println(i)

3.3.2 讨论

在for循环里使用if语句简明可读性高，当然也可以使用传统方式

for (file <- files) {
if (hasSoundFileExtension(file) && !soundFileIsLong(file)) {
soundFiles += file
}
}

一旦习惯Scala的for循环语句，下面的方式更加可读，因为它从业务逻辑中把循环和过滤分开：

for {
file <- files
if passesFilter1(file)
if passesFilter2(file)
} doSomething(file)

3.4 创建一个for/yield组合

问题：在已有集合上每个元素进行运算处理创建一个新的集合

3.4.1 解决方案

使用yield

scala> val names = Array("chris", "ed", "maurice")
names: Array[String] = Array(chris, ed, maurice)

scala> val capNames = for (e <- names) yield e.capitalize
capNames: Array[String] = Array(Chris, Ed, Maurice)

多行运算处理，在yield关键词之后使用代码块执行工作

scala> val lengths = for (e <- names) yield {
| // imagine that this required multiple lines of code
| e.length
| }
lengths: Array[Int] = Array(5, 2, 7)

除了特殊情况，for循环集合返回类型和开始类型是一样的。举例如果循环一个ArrayBuffer,那么返回也是ArrayBuffer

//原集合
var fruits = scala.collection.mutable.ArrayBuffer[String]()
fruits += "apple"
fruits += "banana"
fruits += "orange"

//新集合
scala> val out = for (e <- fruits) yield e.toUpperCase
out: scala.collection.mutable.ArrayBuffer[java.lang.String] =
ArrayBuffer(APPLE, BANANA, ORANGE)

输入时List集合，那么for/yield循环之后返回也是List集合

scala> val fruits = "apple" :: "banana" :: "orange" :: Nil
fruits: List[java.lang.String] = List(apple, banana, orange)

scala> val out = for (e <- fruits) yield e.toUpperCase
out: List[java.lang.String] = List(APPLE, BANANA, ORANGE)

3.4.2 讨论

for/yield工作原理

开始运行时，for/yield循环立刻创建一个和输入集合一样的新的空的集合。比如输入类型是Vector，那么输出就是Vector,可以认为新集合是一个桶。

每次循环，从输入集合的当前元素创建一个新的输出元素，当输出元素创建，就被放置在桶中。

循环结束时，返回这个桶的所有内容。

没有guard的for/yield组合和调用map方法一样：

scala> val out = for (e <- fruits) yield e.toUpperCase
out: List[String] = List(APPLE, BANANA, ORANGE)

scala> val out = fruits.map(_.toUpperCase)
out: List[String] = List(APPLE, BANANA, ORANGE)

3.5 实现break和continue

问题：有一个需要使用break和continue结构的情况，但是Scala没有break和continue关键词

3.5.1 解决方案

Scala没有break和continue关键词，但在scala.util.control.Breaks提供了相同的功能

package com.alvinalexander.breakandcontinue

import util.control.Breaks._

object BreakAndContinueDemo extends App {

println("\n=== BREAK EXAMPLE ===")
breakable {
for (i <- 1 to 10) {
println(i)
if (i > 4) break // break out of the for loop
}
}

println("\n=== CONTINUE EXAMPLE ===")
val searchMe = "peter piper picked a peck of pickled peppers"
var numPs = 0
for (i <- 0 until searchMe.length) {
breakable {
if (searchMe.charAt(i) != 'p') {
break // break out of the 'breakable', continue the outside loop
} else {
numPs += 1
}
}
}
println("Found " + numPs + " p's in the string.")
}

//输出
=== BREAK EXAMPLE ===
1
2
3
4
5

=== CONTINUE EXAMPLE ===
Found 9 p's in the string.

3.5.2 break例子

当i大于4时，运行break“关键词”，此时会抛出一个异常，并且for循环退出。breakable“关键词”捕获这个异常然后运行breakable语句块之后的代码

breakable {
for (i <- 1 to 10) {
println(i)
if (i > 4) break // break out of the for loop
}
}

注意break和breakable并不是真的关键词，他们是scala.util.control.Breaks里的方法。在Scala2.10，break方法被调用时会抛出一个BreakControl异常实例

private val breakException = new BreakControl
def break(): Nothing = { throw breakException }

breakable方法定义成捕获一个BreakControl异常

def breakable(op: => Unit) {
try {
op
} catch {
case ex: BreakControl =>
if (ex ne breakException) throw ex
}
}

更多看3.18章，如何与Breaks库类似的方式实现自己的控制结构

3.5.3 continue例子

代码循环字符串中的每个字符，如果当前字符不是字母p，那么跳出if/then语句，然后继续执行for循环。

执行到break方法后，抛出一个异常，然后被breakable捕获。这个异常跳出if/then语句，然后捕获以允许for循环继续执行后面的元素。

val searchMe = "peter piper picked a peck of pickled peppers"
var numPs = 0

for (i <- 0 until searchMe.length) {
breakable {
if (searchMe.charAt(i) != 'p') {
break // break out of the 'breakable', continue the outside loop
} else {
numPs += 1
}
}
}

println("Found " + numPs + " p's in the string.")

3.5.4 一般语法

实现break和continue功能的一般的语法如下，部分以伪代码方式写，然后与java进行比较。

//break Scala
breakable {
for (x <- xs) {
if (cond)
break
}
}

//break Java
for (X x : xs) {
if (cond) break;
}

//continue Scala
for (x <- xs) {
breakable {
if (cond)
break
}
}

//continue Java
for (X x : xs) {
if (cond) continue;
}

3.5.5 关于continue例子

在Scala中有更好的方法解决continue例子的问题，比如直接的方法是以简单匿名函数使用count方法，此时count依旧是9：

val count = searchMe.count(_ == 'p')

3.5.6 嵌套循环和标记break

在任何情况下，可以创建标记break：

object LabeledBreakDemo extends App {

import scala.util.control._

val Inner = new Breaks
val Outer = new Breaks

Outer.breakable {
for (i <- 1 to 5) {
Inner.breakable {
for (j <- 'a' to 'e') {
if (i == 1 && j == 'c') Inner.break else println(s"i: $i, j: $j")
if (i == 2 && j == 'b') Outer.break
}
}
}
}
}

这个例子中，第一个if条件满足，会抛出一个异常然后被Inner.breakable捕获，外面的for循环继续。不过如果第二个if条件触发，控制流发送到Outer.breakable,然后两个循环都退出。运行结果如下：

i: 1, j: a
i: 1, j: b
i: 2, j: a

如果偏爱标记break使用相同的方法，下面演示只用一个break方法时的标记break使用

import scala.util.control._

val Exit = new Breaks
Exit.breakable {
for (j <- 'a' to 'e') {
if (j == 'c') Exit.break else println(s"j: $j")
}
}

3.5.7 讨论

如果不喜欢使用break和continue,还有其他方法可以解决这个问题。

举例，需要添加猴子到桶中，直到桶装满了。可以利用一个简单的布尔测试来退出for循环

var barrelIsFull = false
for (monkey <- monkeyCollection if !barrelIsFull) {
addMonkeyToBarrel(monkey)
barrelIsFull = checkIfBarrelIsFull
}

另一个方法是在函数里进行计算，当达到所需条件时从函数里返回，下面的例子如果sum比limit大，sumToMax函数提前返回

// calculate a sum of numbers, but limit it to a 'max' value
def sumToMax(arr: Array[Int], limit: Int): Int = {
var sum = 0
for (i <- arr) {
sum += i
if (sum > limit) return limit
}
sum
}
val a = Array.range(0,10)
println(sumToMax(a, 10))

在函数式编程里通用方法是使用递归算法，下面演示阶乘函数：

def factorial(n: Int): Int = {
if (n == 1) 1
else n * factorial(n - 1)
}

需要注意这个例子没有使用尾递归，所以不是最优方法，尤其起始值n特别大时。下面演示利用尾递归的更优方法。

import scala.annotation.tailrec

def factorial(n: Int): Int = {
@tailrec def factorialAcc(acc: Int, n: Int): Int = {
if (n <= 1) acc
else factorialAcc(n * acc, n - 1)
}
factorialAcc(1, n)
}

当确认算法是尾递归这种情况时可以使用@tailrec注解。如果你使用了这个注解但是你的算法不是尾递归，编译器会报错，比如在第一个factorial方法使用注解，会得到如下错误：

Could not optimize @tailrec annotated method factorial: it contains a recursive call not in tail position

查看更多

Branching Statements

Scala factorial on large numbers sometimes crashes and sometimes doesn’t

3.6 像三目运算符一样使用if结构

问题： 使用Scala的if表达式如三目运算符一样更加简洁有效的解决问题

3.6.1 解决方案

不像Java中，在Scala中有点小问题，因为Scala里没有特殊的三目运算符，只能使用if/else表达式：

val absValue = if (a < 0) -a else a

println(if (i == 0) "a" else "b")

hash = hash * prime + (if (name == null) 0 else name.hashCode)

3.6.2 讨论

更多例子如下，返回一个结果并且Scala语法使得代码更加简洁

def abs(x: Int) = if (x >= 0) x else -x

def max(a: Int, b: Int) = if (a > b) a else b

val c = if (a > b) a else b

查看更多

Equality, Relational, and Conditional Operators

3.7 像switch语句一样使用match表达式

问题：需要创建一个基于整数的Java Switch语句，比如匹配一周中的每一天，一年中的每一月，等等其他整数map一个结果的情况。

3.7.1 解决方案

使用Scala的match表达式，像Java Switch语句一样：

// i is an integer
i match {
case 1 => println("January")
case 2 => println("February")
case 3 => println("March")
case 4 => println("April")
case 5 => println("May")
case 6 => println("June")
case 7 => println("July")
case 8 => println("August")
case 9 => println("September")
case 10 => println("October")
case 11 => println("November")
case 12 => println("December")
// catch the default with a variable so you can print it
case whoa => println("Unexpected case: " + whoa.toString)
}

从match表达式返回值的函数方法：

val month = i match {
case 1 => "January"
case 2 => "February"
case 3 => "March"
case 4 => "April"
case 5 => "May"
case 6 => "June"
case 7 => "July"
case 8 => "August"
case 9 => "September"
case 10 => "October"
case 11 => "November"
case 12 => "December"
case _ => "Invalid month" // the default, catch-all
}

3.7.2 @switch注解

如果使用简单match表达式，推荐使用@switch注解。在编译时如果switch不能编译成tableswitch或者lookupswitch时会提供一个警告。

编译成tableswitch或者lookupswitch有更好的性能，因为它的结果是一个分支表而不是决策树。当给表达式一个给定值时，可以直接跳到结果处而不是执行完决策树。

官方文档解释：如果在一个match表达式使用一个注解，编译器会确认这个match是否已经编译成tableswitch或者lookupswitch,如果编译成一系列条件表达式则会发出一个错误。

// Version 1 - compiles to a tableswitch
import scala.annotation.switch

class SwitchDemo {

val i = 1
val x = (i: @switch) match {
case 1 => "One"
case 2 => "Two"
case _ => "Other"
}

}

编译代码：

$ scalac SwitchDemo.scala

反汇编代码

$ javap -c SwitchDemo

//输出
16: tableswitch{ //1 to 2
1: 50;
2: 45;
default: 40 }

输出是一个tableswitch，表明Scala可以优化match表达式成tableswitch

然后进行小改动，使用变量代替整数2：

import scala.annotation.switch

// Version 2 - leads to a compiler warning
class SwitchDemo {

val i = 1
val Two = 2 // added
val x = (i: @switch) match {
case 1 => "One"
case Two => "Two" // replaced the '2'
case _ => "Other"
}
}

//编译
$ scalac SwitchDemo.scalaSwitchDemo.scala:7: warning: could not emit switch for @switch annotated match
val x = (i: @switch) match {
^
one warning found

这个警告是说这个匹配表达式既不能生成tableswitch也不能生成lookupswitch.

在Scala In Depth指出必须满足下面几点才可以应用tableswitch优化

匹配的值必须是已知整数

匹配表达式必须简单，不能包含任何的类型检查，if语句，或者提取器

编译时表达式必须有值

有超过2个的case语句

3.7.3 讨论

不止可以匹配整数：

def getClassAsString(x: Any): String = x match {
case s: String => s + " is a String"
case i: Int => "Int"
case f: Float => "Float"
case l: List[_] => "List"
case p: Person => "Person"
case _ => "Unknown"
}

3.7.4 处理默认的case

如果不关注默认match的值，可以使用_

case _ => println("Got a default match")

相反，如果对默认match的值感兴趣，分配一个变量，然后可以在表达式右边使用变量：

case default => println(default)

使用default名称往往是最有意义的并导致代码可读。但是也可以使用任何合法的变量名称：

case oops => println(oops)

如果不处理默认的case会生成一个MatchError,比如下面：

i match {
case 0 => println("0 received")
case 1 => println("1 is good, too")
}

//如果i的值超过0或1时，会抛出以下异常
scala.MatchError: 42 (of class java.lang.Integer)
at .<init>(<console>:9)
at .<clinit>(<console>)
much more error output here ...

3.7.5 是否真的需要switch语句

如果有一个map的数据结构，并不需要一个switch语句：

val monthNumberToName = Map(
1 -> "January",
2 -> "February",
3 -> "March",
4 -> "April",
5 -> "May",
6 -> "June",
7 -> "July",
8 -> "August",
9 -> "September",
10 -> "October",
11 -> "November",
12 -> "December"
)

val monthName = monthNumberToName(4)
println(monthName) // prints "April"

查看更多

The @switch annotation documentation

Compiling Switches：讨论tableswitch和lookupswitch

Difference between JVM’s LookupSwitch and TableSwitch?