一、前言
前面学习了Scala的Numbers，接着学习Scala的Control Structures(控制结构)。
二、Control Structures
Scala中的控制结构与Java中的颇为类似，但也有所不同，例如，if/then/else控制结构与Java的类似，但是其可以返回值，虽然Java中有三元运算符的特殊语法，但是在Scala中使用if就可以达到同样的效果。
val x = if (a) y else z
同样，Scala的try/catch/finally 结构与Java的也类似，但是Scala在catch中时使用的模式匹配。
当使用for循环时，情况会变得更有趣，for循环的基本用法在Scala和Java中都相同，但是在Scala可以添加守卫。例如，可以使用两个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中，使用for循环可以让你能够很轻易的将一个集合转化成另外一个集合
在最基础的使用中，Scala的match表达式与Java的Switch语句类似，你可以匹配任何对象，并且从对象中解析信息。
2.1 for和foreach循环
1. 问题描述
你需要遍历集合的元素，或者操作集合中的元素，或者在已有集合上创建新的集合
2. 解决方案
有很多方式可以遍历集合，如for、while循环，还有集合的foreach、map、flatMap方法等，首先看看for循环
当你的算法有多行时，也可以使用for循环，如下所示
上述示例中仅仅只是遍历了集合中的元素，并且没有返回值，如新的Array，当你想要从已有集合中创建新的集合时，可以使用for/yield
for/yield结构返回了一个新的Array。
当在for循环中需要访问计数器时，可以使用如下方法
Scala集合也提供了zipWithIndex方法来创建循环计数器
下面示例展示了如何通过Range来执行循环三次
如下示例展示了如何使用守卫(在for循环中使用if语句)
可以使用如下精炼方式遍历Map的键集合和值集合
3. 讨论
当你在集合上使用for/yield时，会得到一个新的集合，而仅仅使用for时，则不会产生新的集合，仅仅只是利用for的副作用对集合元素进行操作。for循环可能不是遍历集合最好的方式，使用foreach、map、flatMap、collect、reduce等方法可能会更高效的解决问题。
你可以调用foreach方法来遍历每个集合元素
可以使用匿名函数对元素进行操作
for循环如何被翻译
· for循环会被编译器翻译成foreach方法
· 有守卫的for循环会被翻译成withFilter方法(在foreach之后)
· 有yield的for循环会被翻译成map方法
· 有yield和守卫的for循环会被翻译成withFilter(在map之后)
为了验证for循环的翻译过程，新建Main.scala文件，源代码如下
class Main {
for (i <- 1 to 10) println(i)
}
使用scalac -Xprint:parse Main.scala命令进行编译
可以看到for循环被翻译成了foreach方法
其他的带守卫、yield的for循环也可以采用上述方法进行查看，不再累赘
2.2 使用多计数器的for循环
1. 问题描述
你想要创建拥有多个计数器的循环，如当遍历一个多维数组
2. 解决方案
你可以使用如下方法创建多个计数器
一种更好的方式是使用中括号
同理，也可以使用三个计数器
当遍历多位数组时，该方法很有效
3. 讨论
在循环中，使用<-符号生成Range被称为生成器，可以在一个循环中使用多个生成器
2.3 使用内嵌语句的for循环
1. 问题描述
你想要在for循环中添加一个或多个条件子句，通常在筛选集合中的某些元素
2. 解决方案
可以在生成器后面添加if语句
或者使用中括号
上述的if语句被称为过滤器或守卫，下面示例添加了多个守卫
3. 讨论
在for循环中使用守卫可以是代码精炼并且提高可读性，当然也可以使用传统的方法
2.4 创建for/yield组合
1. 问题描述
你想要通过对原始集合中的每个元素应用某种算法（一个或多个守卫）来从现有集合创建新的集合
2. 解决方案
使用yield和算法来从现有集合生成新的集合
如果算法有多行，可以采用如下形式
通常情况下，使用yield新生的集合的类型和原始集合的类型相同，如原始集合时ArrayBuffer类型，则新生的集合也是ArrayBuffer类型
3. 讨论
当在for循环中使用yield时，可以将其看做如下
· 开始运行时，for/yield会新建一个空的集合，类型和原始集合类型相同
· 在for循环的每次迭代中，从输入集合的当前元素创建新的输出元素，放置在新的集合中
· 当for循环结束时，返回新的集合中的所有内容
没有守卫的for/yield语句就相当于调用集合的map方法
2.5 实现break和continue
1. 问题描述
你需要使用break和continue，但是在Scala中并没有break和continue关键字
2. 解决方案
scala.util.control.Breaks提供了break功能
package com.hust.grid.leesf.breakcontinue /**
* Created by LEESF on 2017/1/18.
*/
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.
值得注意的是break和breakable都不是Scala的关键字，它们是scala.util.control.Breaks包下的方法
private val breakException = new BreakControl
def break(): Nothing = { throw breakException }
def breakable(op: => Unit) {
try {
op
} catch {
case ex: BreakControl =>
if (ex ne breakException) throw ex
}
}
可以看到在调用break方法时，会抛出一个异常，此时breakable会捕捉到此异常，利用这种方式实现了break和continue的功能
3. 讨论
如果你不喜欢使用break和continue时，可以使用如下方法，如可以使用带有守卫的for循环
var barrelIsFull = false
for (monkey <- monkeyCollection if !barrelIsFull) {
addMonkeyToBarrel(monkey)
barrelIsFull = checkIfBarrelIsFull
}
或者使用return直接返回
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))
2.6 使用类似三元运算符的if表达式
1. 问题描述
你需要使用if表达式来像三元运算符那样简洁的解决问题
2. 解决方案
在Scala中没有三元运算法，但是可以使用if/else表达式
3. 讨论
在Java中可以使用?:三元运算符，在Scala可以使用if/else表达式
2.7 使用类似switch语句的match表达式
1. 问题描述
你想要创建向Java那样简单的switch语句，如星期几，哪一月
2. 解决方案
使用Scala的match表达式
// 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
}
当写match表达式时，推荐使用@switch注解，当switch不能编译成一个tableswitch或lookupswitch，该注解会提供编译时警告，将switch编译成tableswitch或lookupswitch会有更高的性能，因为结果是在分支表而不是一个决策树里，当给表达式赋值时，它可以直接跳转到结果，而不是遍历决策树
import scala.annotation.switch
class SwitchDemo {
val i = 1
val x = (i: @switch) match {
case 1 => "One"
case 2 => "Two"
case _ => "Other"
}
}
先使用scalac SwitchDemo命令进行编译，然后使用javap SwitchDemo命令反编译
可以看到生成了tableswitch表，当修改代码如下时
import scala.annotation.switch
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命令进行编译
这表明match表达式无法生成tableswitch或lookupswitch，当使用javap命令反汇编时，也找不到tableswitch
3. 讨论
match表达式非常灵活，可以匹配不同的类型
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"
}
可以使用case _通配符来匹配之前的所有case无法匹配的情况，或者使用case default进行赋值
case default => println(default)
2.8 用一个case语句匹配多个条件
1. 问题描述
当几个匹配条件要求执行相同的业务逻辑，你想要使用业务逻辑的一个副本来匹配条件，而不是为每个case重复业务逻辑
2. 解决方案
将匹配条件放在一行使用|分割
val i = 5
i match {
case 1 | 3 | 5 | 7 | 9 => println("odd")
case 2 | 4 | 6 | 8 | 10 => println("even")
}
同理，该语法也适用于字符串或其他类型
val cmd = "stop"
cmd match {
case "start" | "go" => println("starting")
case "stop" | "quit" | "exit" => println("stopping")
case _ => println("doing nothing")
}
trait Command case object Start extends Command
case object Go extends Command
case object Stop extends Command
case object Whoa extends Command def executeCommand(cmd: Command) = cmd match {
case Start | Go => start()
case Stop | Whoa => stop()
}
2.9. 将match表达式的值赋值给变量
1. 描述
你想要将匹配表达式返回值其赋值给变量，或使用匹配表达式作为方法的主体
2. 解决方案
在表达式之前插入变量
val evenOrOdd = someNumber match {
case 1 | 3 | 5 | 7 | 9 => println("odd")
case 2 | 4 | 6 | 8 | 10 => println("even")
}
这种方法经常被用作创建短的方法或函数
def isTrue(a: Any) = a match {
case 0 | "" => false
case _ => true
}
2.10 访问匹配表达式默认情况下的值
1. 问题描述
你想要访问默认匹配值，但是使用通配符时无法访问到值
2. 解决方案
在默认情况下指定变量名而非_通配符
i match {
case 0 => println("1")
case 1 => println("2")
case default => println("You gave me: " + default)
}
通过给默认匹配变量名称，你可以在语句右侧访问该变量
3. 讨论
在默认匹配时使用变量名而非通配符，若没有给出通配符时，可能抛出异常
2.11 在匹配表达式中使用模式匹配
1. 问题描述
你需要在匹配表达式中匹配一个或多个模式，该模式可以是常量模式、变量模式、构造函数模式、序列模式、元组模式或类型模式等
2. 解决方案
为要匹配的每个模式定义一个case语句
def echoWhatYouGaveMe(x: Any): String = x match {
// constant patterns
case 0 => "zero"
case true => "true"
case "hello" => "you said 'hello'"
case Nil => "an empty List"
// sequence patterns
case List(0, _, _) => "a three-element list with 0 as the first element"
case List(1, _*) => "a list beginning with 1, having any number of elements"
case Vector(1, _*) => "a vector starting with 1, having any number of elements"
// tuples
case (a, b) => s"got $a and $b"
case (a, b, c) => s"got $a, $b, and $c"
// constructor patterns
case Person(first, "Alexander") => s"found an Alexander, first name = $first"
case Dog("Suka") => "found a dog named Suka"
// typed patterns
case s: String => s"you gave me this string: $s"
case i: Int => s"thanks for the int: $i"
case f: Float => s"thanks for the float: $f"
case a: Array[Int] => s"an array of int: ${a.mkString(",")}"
case as: Array[String] => s"an array of strings: ${as.mkString(",")}"
case d: Dog => s"dog: ${d.name}"
case list: List[_] => s"thanks for the List: $list"
case m: Map[_, _] => m.toString
// the default wildcard pattern
case _ => "Unknown
}
上述方法可以匹配不同的类型和模式
3. 讨论
通常使用此技术时，你的方法希望传入的是基类或特性继承的实例，然后case语句引用该基类型的子类型
import java.io.File sealed trait RandomThing case class RandomFile(f: File) extends RandomThing
case class RandomString(s: String) extends RandomThing class RandomNoiseMaker {
def makeRandomNoise(t: RandomThing) = t match {
case RandomFile(f) => playSoundFile(f)
case RandomString(s) => speak(s)
}
}
sealed表示密封的特质，其子类必须全部给出。
有时你可能需要向模式添加变量，你可以用下面的一般语法：
变量名 @ 模式
这表示变量绑定模式，这种模式的含义是按照正常模式进行模式匹配，如果模式匹配成功，就像简单的变量模式一样，将变量设置为匹配对象。
当匹配List类型时，我们可以如下
case list: List[_] => s"thanks for the List: $list"
当我们想要匹配以元素1作为头元素的列表时，我们可能会进行如下匹配
case list: List(1, _*) => s"thanks for the List: $list"
但此时会报错
解决办法是添加变量绑定模式
case list @ List(1, _*) => s"$list"
2.12. 在匹配表达式中使用案例类
1. 问题描述
你希望在匹配表达式中匹配不同的case类（或case对象），如接收actor的消息时
2. 解决方案
根据你的需要可以使用之前的不同模式进行匹配
trait Animal case class Dog(name: String) extends Animal
case class Cat(name: String) extends Animal
case object Woodpecker extends Animal object CaseClassTest extends App {
def determineType(x: Animal): String = x match {
case Dog(moniker) => "Got a Dog, name = " + moniker
case _:Cat => "Got a Cat (ignoring the name)"
case Woodpecker => "That was a Woodpecker"
case _ => "That was something else"
} println(determineType(new Dog("Rocky")))
println(determineType(new Cat("Rusty the Cat")))
println(determineType(Woodpecker))
}
2.13 将if表达式（守卫）添加到case语句中
1. 问题描述
你希望将匹配逻辑添加到匹配表达式中的case语句中，例如允许一系列数字或匹配模式，但仅当该模式与某些附加条件相匹配时
2. 解决方案
将if表达式添加至case语句中
i match {
case a if 0 to 9 contains a => println("0-9 range: " + a)
case b if 10 to 19 contains b => println("10-19 range: " + b)
case c if 20 to 29 contains c => println("20-29 range: " + c)
case _ => println("Hmmm...")
}
可以匹配不同的值
num match {
case x if x == 1 => println("one, a lonely number")
case x if (x == 2 || x == 3) => println(x)
case _ => println("some other value")
}
也可以在匹配时解析出字段信息
def speak(p: Person) = p match {
case Person(name) if name == "Fred" => println("Yubba dubba doo")
case Person(name) if name == "Bam Bam" => println("Bam bam!")
case _ => println("Watch the Flintstones!")
}
3. 讨论
在进行匹配时也可将if放在=>的右侧
case Person(name) =>
if (name == "Fred") println("Yubba dubba doo")
else if (name == "Bam Bam") println("Bam bam!")
2. 14 使用匹配表达式而非isInstanceOf
1. 问题描述
你需要编写匹配一种类型或多个不同类型的代码块
2. 解决方案
你可以使用isInstanceOf来测试对象的类型
if (x.isInstanceOf[Foo]) { do something ...}
然而并不鼓励这样做，更好的办法是使用匹配表达式
def isPerson(x: Any): Boolean = x match {
case p: Person => true
case _ => false
}
或者给出一个继承已知父类的子类，需要根据子类的不同做出不同的操作
trait SentientBeing
trait Animal extends SentientBeing case class Dog(name: String) extends Animal
case class Person(name: String, age: Int) extends SentientBeing def printInfo(x: SentientBeing) = x match {
case Person(name, age) => // handle the Person
case Dog(name) => // handle the Dog
}
3. 讨论
匹配表达式可以匹配多种类型，而不需要使用isInstanceOf方法
2. 15. 在匹配表达式中使用列表
1. 问题描述
列表数据结构与其他集合数据结构有点不同，它从cons cells开始构建，并以Nil作为结尾，在使用匹配表达式时你想要利用此特性，例如编写递归程序
2. 解决方案
你可以使用如下方法创建List
当编写递归函数时，你可以利用其尾元素是Nil类型对象
3. 讨论
在REPL中构建List时，不要忘记Nil情况
2.16 使用try/catch匹配一个或多个异常
1. 问题描述
在try/catch块中你想要匹配一个或多个异常
2. 解决方案
Scala的try/catch/finally与Java类型，但是在catch中使用的是模式匹配
val s = "Foo"
try {
val i = s.toInt
} catch {
case e: Exception => e.printStackTrace
}
当你需要匹配多个异常时，在catch添加即可
try {
openAndReadAFile(filename)
} catch {
case e: FileNotFoundException => println("Couldn't find that file.")
case e: IOException => println("Had an IOException trying to read that file")
}
3. 讨论
Scala中的catch块可以匹配多个异常，如果你不关心发生的异常，可以使用如下方式
try {
openAndReadAFile("foo")
} catch {
case t: Throwable => t.printStackTrace()
}
try {
val i = s.toInt
} catch {
case _: Throwable => println("exception ignored")
}
2.17 在try/catch/finally块之前声明变量
1. 问题描述
当你需要调用对象的闭包方法，你想要在try块中使用一个对象，并且在finally块中访问它
2. 解决方案
在try之前将字段声明为Option类型，之后在try块中创建一个Some对象
import java.io._
object CopyBytes extends App {
var in = None: Option[FileInputStream]
var out = None: Option[FileOutputStream]
try {
in = Some(new FileInputStream("/tmp/Test.class"))
out = Some(new FileOutputStream("/tmp/Test.class.copy"))
var c = 0
while ({c = in.get.read; c != −1}) {
out.get.write(c)
}
} catch {
case e: IOException => e.printStackTrace
} finally {
println("entered finally ...")
if (in.isDefined) in.get.close
if (out.isDefined) out.get.close
}
}
2.18 自定义控制结构
1. 问题描述
你想要自定义控制结构来改善Scala语言
2. 解决方案
假如有一天你不喜欢while结构，而是如下结构
package foo
import com.alvinalexander.controls.Whilst._
object WhilstDemo extends App {
var i = 0
whilst (i < 5) {
println(i)
i += 1
}
}
此时，whilist就是你自定义的控制结构，你可能采用如下方法定义whilist方法
def whilst(testCondition: => Boolean)(codeBlock: => Unit) {
while (testCondition) {
codeBlock
}
}
但是更好的方法是不调用while循环
package com.leesf.controls
import scala.annotation.tailrec
object Whilst {
// 2nd attempt
@tailrec
def whilst(testCondition: => Boolean)(codeBlock: => Unit) {
if (testCondition) {
codeBlock
whilst(testCondition)(codeBlock)
}
}
}
3. 讨论
在第二版的whilist中，使用了递归调用，假设有一个两个参数的控制结构，当都为真时执行代码块，调用代码如下
doubleif(age > 18)(numAccidents == 0) { println("Discount!") }
doubleif方法则可定义如下
def doubleif(test1: => Boolean)(test2: => Boolean)(codeBlock: => Unit) {
if (test1 && test2) {
codeBlock
}
}
其中，codeBlock: => Unit对应的是println("Discount!")
三、总结
本篇博文学习了Scala的控制结构及其细节，同时还学习了自定义控制结构，也谢谢各位园友的观看~