【Scala】Scala之Control Structures
一、前言
前面学习了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的控制结构及其细节,同时还学习了自定义控制结构,也谢谢各位园友的观看~
【Scala】Scala之Control Structures的更多相关文章
- Scala Control Structures
Scala之Control Structures 一.前言 前面学习了Scala的Numbers,接着学习Scala的Control Structures(控制结构). 二.Control Struc ...
- Python - 4. Control Structures
From:http://interactivepython.org/courselib/static/pythonds/Introduction/ControlStructures.html Cont ...
- R Programming week2 Control Structures
Control Structures Control structures in R allow you to control the flow of execution of the program ...
- [Scala] Scala基础知识
Object An object is a type of class that can have no more than one instance, known in object-oriente ...
- [scala] scala 集合(⑧)
1.List 基础操作 2.Set 基础操作 3. TreeSet 排序Set 4. 拉链操作 5. 流 import scala.collection.immutable.TreeSet impor ...
- [scala] scala 函数 (⑦)
1.scala 函数定义 2.scala 高阶函数 3.匿名函数 4.柯里化 import scala.math._ /** * @author xwolf * @date 2017-04-24 9: ...
- [Scala]Scala学习笔记七 正则表达式
1. Regex对象 我们可以使用scala.util.matching.Regex类使用正则表达式.要构造一个Regex对象,使用String类的r方法即可: val numPattern = &q ...
- [Scala]Scala学习笔记六 文件
1. 读取行 读取文件,可以使用scala.io.Source对象的fromFile方法.如果读取所有行可以使用getLines方法: val source = Source.fromFile(&qu ...
- [Scala]Scala学习笔记五 Object
1. 单例对象 Scala没有静态方法或静态字段,可以使用object来达到这个目的,对象定义了某个类的单个实例: object Account{ private var lastNumber = 0 ...
随机推荐
- Xcode制作插件
转发至:https://onevcat.com/2013/02/xcode-plugin/ Xcode 4 插件制作入门 本文欢迎转载,但烦请保留此行出处信息:http://www.onevcat.c ...
- Codeforces #377 Div2
打得还不错的一场CF,题目质量也很高,今后还要继续努力 A题: 题意:给定一个数k,让其乘一个最小的数,使乘得以后的数要不被10整除,要不减去r以后被10整除,求这个最小的数 #include < ...
- Java Restful框架:Jersey入门示例(官方例子)
本文主要介绍了Java Restful框架Jersey入门例子(来源于官方网站https://jersey.java.net/),废话不多说进入正题. 在Jersey官方示例中(https://jer ...
- Firefox 插件 JSview是一套比较实用的JS,CSS文件查看工具,很方便,很快捷地查看页面引用了哪些文件,作为Web前端开发者是一套必备的插件,由于Firefox升级过快,插件很快不兼容了,这里对插件做了一些调整,可以兼容最新Firefox浏览器(目前FireFox 21)
JSView Firefox Plugins Download 点击下载
- /etc/profile文件
导读:Linux /etc/profile文件的改变会涉及到系统的环境,也就是有关Linux环境变量的东西,学习Linux要了解Linux profile文件的相关原理,这里对则以文件进行具体分析.这 ...
- LED调光,PFM即pulse frequence modulation
PWM不是唯一的调制方式,可以PWM,也可以PFM,也可以混合调制. PWM即pulse width modulation的缩写,脉冲宽度调制,保持开关周期不变,调节开关导通时间. PFM即pulse ...
- jstl-按照html的形式输出至页面
一.按照html的形式输出至页面 <c:out value="${xxx}" default="默认值" escapeXml="false&qu ...
- 在Windows环境下设置terminal下调试adb
当我们想要查看某些程序运行的结果的时候.可能需要打开adb,输入相应的命令,在Windows环境下,需要配置环境变量. 当我们直接在Windows环境下输入adb shell,会提示adb是不内部命令 ...
- iOS搜索框UISearchBar 分类: ios技术 2015-04-03 08:55 82人阅读 评论(0) 收藏
当你在seachBar中输入字母之前的时候,只是用鼠标选中searchBar的时候,如图 终端输出截图如下:(这个时候调用先shouldBeginEditing,之后调用didBeginEditing ...
- php包管理工具最基本的一些问题
windows下的 1.先安装windows下的set-up程序 点击一步步的, cmd进入,输入composer能成功显示一幅图说明安装成功 2.在下载,https://getcomposer.or ...