【Scala】——流程控制

1 if-else 分支控制

让程序有选择的的执行，分支控制有三种：单分支、双分支、多分支

1.1单分支

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

1.2 双分支

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

1.3 多分支

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

1.4 if-else 表达式返回值

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

package com.scala
package chapter04

import scala.io.StdIn

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

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

package com.scala
package chapter04

import scala.io.StdIn

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

  }

}

1.5 嵌套分支

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

if () {
  if () {
  } else {

  }
}

2 for 循环控制

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

2.1 范围数据循环（To）

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

i 将会从 1-3 循环，前后闭合

2.2 范围数据循环（Until）

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

这种方式和前面的区别在于 i 是从 1 到 4，即使前闭合后开的范围

2.3 循环守卫

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

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

普通写法：

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

2.4 循环步长（by）

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

by 表示步长

2.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)
  }
}

2.6 引入变量

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

• 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)
}

2.7 循环返回值

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

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

2.8 倒序打印

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

3 While 和do…While循环结构

3.1 While循环控制

循环变量初始化 
while (循环条件) {  
    循环体(语句)  
    循环变量迭代 
}

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

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

3.2 do…While循环控制

循环变量初始化;  
do{ 
    循环体(语句)
    循环变量迭代  
} while(循环条件)

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

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

4 循环中断

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

package com.scala
package chapter04

import scala.util.control.Breaks
import scala.util.control.Breaks.{break, breakable}

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

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

    for (elem <- 1 to 10) {
      if (elem % 2 == 1) {
        println(elem)
      } else {
        println("continue")
      }
    }


  }


}