Scala流程控制

一、分支控制——if-else

1、单分支

同Java、python一样，Scala也有相同的语法，格式为：

if （条件表达式） {
    需要执行的代码块
}
说明：当条件表达式为 ture 时，就会执行{ }的代码。

举个栗子：输入年龄，如果年龄小于 18 岁，则输出“童年”

import scala.io.StdIn

object Shangke {
  def main(args: Array[String]): Unit = {

    println("input age:")
    var age = StdIn.readShort()

    if (age < 18) {
      println("童年")
    }
  }
}

说明：由于存在键盘输入部分，所以需要导包“import scala.io.StdIn”

2、双分支

基本语法：

if (条件表达式) {
    执行代码块 1
} else {
    执行代码块 2
}

举个栗子：

输入年龄，如果年龄小于 18 岁，则输出“童年”。否则，输出“成年”

import scala.io.StdIn

object Shangke {
  def main(args: Array[String]): Unit = {

    println("input age:")
    var age = StdIn.readShort()
    if (age < 18) {
      println("童年")
    }else{
      println("成年")
    }
  }
}

3、多分支

基本语法：

if (条件表达式 1) {
    执行代码块 1
}
else if (条件表达式 2) {
    执行代码块 2
}
.....
else {
    执行代码块n
}

举个栗子：

输入年龄，输出对应的称谓

import scala.io.StdIn

object Shangke {
  def main(args: Array[String]): Unit = {
    println("input age:")
    var age = StdIn.readShort()
    if (0 <= age && age <= 20) {
      println("及冠")
    }else if (20 < age && age <= 30){
      println("而立")
    }else if (30 < age && age <= 40 ){
      println("不惑")
    }else if (40 < age && age <= 50 ){
      println("知天命")
    }else if (50 < age && age <= 60 ){
      println("耳顺或花甲")
    }else if (60 < age && age <= 70 ){
      println("古稀")
    }else if (70 < age && age <= 80 ){
      println("耄耋")
    }else if (80 < age && age <= 90 ){
      println("鲐背")
    }else if (90 < age && age <= 100 ){
      println("期颐")
    }
  }
}

说明：与Java、python不同，若条件表达式有两个以上时，必须用运算符隔开，否则会报错。

栗子拓展：

Scala 中 if else 表达式其实是有返回值的，具体返回值取决于满足条件的代码体的最后一行内容。

import scala.io.StdIn

object Shangke {
  def main(args: Array[String]): Unit = {
    println("input age:")
    var age = StdIn.readShort()
    val res : String = if (0 <= age && age <= 20) {"及冠"
    }else if (20 < age && age <= 30){"而立"
    }else if (30 < age && age <= 40 ){"不惑"
    }else if (40 < age && age <= 50 ){"知天命"
    }else if (50 < age && age <= 60 ){"耳顺或花甲"
    }else if (60 < age && age <= 70 ){"古稀"
    }else if (70 < age && age <= 80 ){"耄耋"
    }else if (80 < age && age <= 90 ){"鲐背"
    }else{"期颐"}
    println(res)
  }
}

由此可以看出Scala中同Java、python不同，Scala的返回值为”res“，不仅使代码体量更小也更加浅显易懂。

栗子拓展：

Scala 中返回值类型不一致，取它们共同的祖先类型。

import scala.io.StdIn

object Shangke {
  def main(args: Array[String]): Unit = {
    println("input age:")
    var age = StdIn.readShort()
    val res:Any = if (0 <= age && age <= 20) {"及冠"
    }else if (20 < age && age <= 30){"而立"
    }else if (30 < age && age <= 40 ){"不惑"
    }else if (40 < age && age <= 50 ){"知天命"
    }else if (50 < age && age <= 60 ){"耳顺或花甲"
    }else if (60 < age && age <= 70 ){"古稀"
    }else if (70 < age && age <= 80 ){"耄耋"
    }else if (80 < age && age <= 90 ){"鲐背"
    }else{100}
    println(res)
  }
}

 栗子拓展：

Java 中的三元运算符可以用 if else 实现。

import scala.io.StdIn

object Shangke {
  def main(args: Array[String]): Unit = {
    //java
    //int result = flag?1:0

    //scala
    println("input age:")
    var age = StdIn.readInt()
    val res:Any = if (age <= 18) "童年" else "成年"
    "不起作用"

    println(res)
  }
}

如果大括号{}内的逻辑代码只有一行，大括号可以省略。如果省略大括号，if 只对最近的一行逻辑代码起作用。

二、嵌套分支

在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层。分支外面的分支结构称为外层分支。嵌套分支不要超过 3 层。

基本语法：

if (条件表达式 1){
    if(条件表达式 2){
    执行代码块 2
    }else{
    执行代码块 3
  }
  执行代码块 1
}

举个栗子：

如果输入的年龄小于 18，返回“童年”。如果输入的年龄大于等于 18，需要再判断：如果年龄大于等于 18 且小于 30，返回“中年”；如果其他，返回“老年”。

import scala.io.StdIn

object Shangke {
  def main(args: Array[String]): Unit = {
      println("input age：")
      var age = StdIn.readInt()
      val res: String = if (age < 18) {"童年"
      } else {
        if (age >= 18 && age < 30) {"中年"
        } else {"老年"}
      }
      println(res)
    }
  }

三、switch分支结构

在 Scala 中没有 Switch，而是使用模式匹配来处理（类似Java的switch语法）。

由于内容原因不在这详细介绍，详细的在后面说。

四、For循环

Scala 也为 for 循环这一常见的控制结构提供了非常多的特性，这些 for 循环的特性被称为 for 推导式或 for 表达式。

1、范围数据循环（To）

基本语法：

for(i <- 1 to 3){
    print(i + " ")
}
println()

for(i <- 1 until 3) { print(i + " ")
}
println()

object Shangke {
  def main(args: Array[String]): Unit = {
      { for(i <- 1 until 5 + 1){
        println("scala")
      }
    }
  }
}

scala 
scala 
scala 
scala 
scala 

Process finished with exit code 0

 3、循环守卫

是的你没看错它就叫这个名字。

循环守卫，即循环保护式（也称条件判断式，守卫）。保护式为 true 则进入循环体内部，为 false 则跳过，类似于 continue。

基本语法：

for(i <- 1 to 3 if i != 2) 
    { print(i + " ")
}
println()

或者

for (i <- 1 to 3){
    if (i != 2) {
        print(i + " ")
    }
}

举个栗子：

输出 1 到 5 中，不等于 3 的值

object Shangke {
  def main(args: Array[String]): Unit = {
        for (i <- 1 to 5 if i != 3) {
        println(i)
    }
  }
}

输出结果：

1
2
4
5

Process finished with exit code 0

4、循环步长

基本语法：（by 表示步长）

for (i <- 1 to 10 by 2) 
    { println("i=" + i)
}

举个栗子：

输出 1 到 10 以内的所有奇数

object Shangke {
  def main(args: Array[String]): Unit = {
    for (i <- 1 to 10 by 2) { 
        println("i = " + i)
    }
  }
}

输出结果：

i = 1
i = 3
i = 5
i = 7
i = 9

Process finished with exit code 0

5、嵌套循环

基本语法

for(i <- 1 to 3; j <- 1 to 3) { println(" i =" + i + " j = " + j)
}

说明：没有关键字，所以范围后一定要加；来隔断逻辑

上面的代码等价

for (i <- 1 to 3) {
for (j <- 1 to 3) {
println("i =" + i + " j=" + j)
}
}

6、引入变量

基本语法

for(i <- 1 to 3; j = 4 - i) { println("i=" + i + " j=" + j)
}

说明： 

1. for 推导式一行中有多个表达式时，所以要加 ; 来隔断逻辑。
2. for 推导式有一个不成文的约定：当 for 推导式仅包含单一表达式时使用圆括号， 当包含多个表达式时，一般每行一个表达式，并用花括号代替圆括号。

for {
i <- 1 to 3 j = 4 - i
} {
println("i=" + i + " j=" + j)
}

 上面的代码等价

for (i <- 1 to 3) { var j = 4 - i
println("i=" + i + " j=" + j)
}

7、循环返回值

基本语法

val res = for(i <- 1 to 10) yield i
println(res)

 说明：将遍历过程中处理的结果返回到一个新 Vector 集合中，使用 yield 关键字。但是在开发中很少使用。

举个栗子：

将原数据中所有值乘以 2，并把数据返回到一个新的集合中。

object TestFor {
def main(args: Array[String]): Unit = { var res = for(i <-1 to 10) yield {
i * 2
}
println(res)
}
}

输出结果为： Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

8、倒序打印（reverse）

举个栗子：

倒序打印 10 到 1

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

9、 While 和 do..While 循环控制

While 和 do..While 的使用和 Java 语言中用法相同。

1）While 循环控制

基本语法

循环变量初始化

while (循环条件) {

循环体(语句)

循环变量迭代

}

说明：

1. 循环条件是返回一个布尔值的表达式
2. while 循环是先判断再执行语句
3. 与 for 语句不同，while 语句没有返回值，即整个 while 语句的结果是Unit 类型()
4. 因为 while 中没有返回值，所以当要用该语句来计算并返回结果时，就不可避免的使用变量，而变量需要声明在 while 循环的外部，那么就等同于循环的内部对外部的变量造成了影响，所以不推荐使用，而是推荐使用 for 循环。

举个栗子：

 输出 10 句 " scala"

object TestWhile {

def main(args: Array[String]): Unit = { var i = 0
while (i < 10) {
println("scala" + i) i += 1
}
}
}

2） do..while 循环控制

基本语法

循环变量初始化

循环体(语句)

循环变量迭代

} while(循环条件)

说明:

1. 循环条件是返回一个布尔值的表达式
2. do..while 循环是先执行，再判断

举个栗子：

输出 10 句 " scala"

object TestWhile {

def main(args: Array[String]): Unit = { var i = 0
do {
println("scala" + i) i += 1
} while (i < 10)
}
}

3）循环中断

 Scala 内置控制结构特地去掉了 break 和 continue，是为了更好的适应函数式编程，推荐使用函数式的风格解决break 和continue 的功能，而不是一个关键字。Scala 中使用breakable 控制结构来实现 break 和 continue 功能。

栗子：

1：采用异常的方式退出循环

def main(args: Array[String]): Unit = {
    try {
        for (elem <- 1 to 10) 
            { println(elem)
            if (elem == 5) throw new RuntimeException
        }
    }catch {
    case e =>
    }
    println("正常结束循环")
}

  2：采用 Scala 自带的函数，退出循环

import scala.util.control.Breaks
def main(args: Array[String]): Unit = { Breaks.breakable(
for (elem <- 1 to 10) { println(elem)
if (elem == 5) Breaks.break()
}
)

println("正常结束循环")
}

  3：对break 进行省略

import scala.util.control.Breaks._ object TestBreak {
def main(args: Array[String]): Unit = {

breakable {
for (elem <- 1 to 10) { println(elem)
if (elem == 5) break
}
}

println("正常结束循环")
}
}

  4：循环遍历 10 以内的所有数据，奇数打印，偶数跳过（continue）

object TestBreak {
def main(args: Array[String]): Unit = { for (elem <- 1 to 10) {
if (elem % 2 == 1) { println(elem)
} else {
println("continue")
}
}
}
}

3）多重循环

 将 一 个 循 环 放 在 另 一 个 循 环 体 内 ， 就 形 成 了 嵌 套 循 环 。 其 中 ，for，while，do…while均可以作为外层循环和内层循环。【建议一般使用两层，最多不要超过 3 层】。设外层循环次数为m 次，内层为 n 次，则内层循环体实际上需要执行 m*n 次。

栗子：

打印九九乘法表

object TestWhile {

def main(args: Array[String]): Unit = { for (i <- 1 to 9) {
for (j <- 1 to i) {
print(j + "*" + i + "=" + (i * j) + "\t")
}

println()
}
}
}