4. Scala程序流程控制

4.1 程序流程控制说明

　　　　　　在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句，顺序控制，粉质控制，循环控制

　　　　　　温馨提示：Scala语言中控制结构和Java语言中的控制结构基本相同，在不考虑特殊应用场景的情况下，代码书写方式以及理解方式都没有太大的区别

4.2 顺序控制说明

　　4.2.1 顺序控制介绍

　　　　　　程序从上到下逐航地执行，中间没有任何判断和跳转

　　4.2.2 顺序控制举例和注意事项

4.3 分支控制if-else

　　4.3.1 分支控制if-else介绍

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

　　4.3.2 单分支的使用

　　　　　　基本语法

　　　　　　if(条件表达式){

　　　　　　　　执行代码块

　　　　　　}

　　　　　　案例演示

//import scala.io.StdIn 单独的引入一个StdIn
import scala.io._ // _表示将 scala.io 包的所有内容一起引入

object boke_demo01 {

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

    println("输入年龄")
    val age = StdIn.readInt()
    if (age > 22) {
      println("age > 22")
    }

    //小的技巧，如何查看某个包下包含的内容
    //1.比如我们想看 scala.io 包有什么内容
    //2.将光标放在 io上即可，输入ctrl +b
    //3.将光标放在 StdIn上即可，输入ctrl +b,看的是StdIn源码
    scala.io.StdIn

  }

}

　　4.3.3 双分支

　　　　　　基本语法

　　　　　　if(条件表达式){

　　　　　　　　执行代码块1

　　　　　　} else {

　　　　　　　　执行代码块2

　　　　　　}

　　　　　　说明：当条件表达式成立时，即执行代码块1，否则执行代码块2

　　　　　　案例演示

object boke_demo01 {

  //编写一个程序,可以输入人的年龄,如果该同志的年龄大于18岁,则输出“age >18”。否则 ,输出 "age <= 18 "
  def main(args: Array[String]): Unit = {

    val age = 22
    if (age > 18) {
      println("age > 18")
    } else {
      println("age <= 18")
    }
  }

}

　　4.3.4 多分支

　　　　　　基本语法

　　　　　　if(条件表达式1){

　　　　　　　　执行代码块1

　　　　　　} else if(条件表达式2){

　　　　　　　　执行代码块2

　　　　　　}

　　　　　　　　.......

　　　　　　else {

　　　　　　　　执行代码块n

　　　　　　}

　　4.3.5 分支控制if-else注意事项

　　　　　　1) 如果大括号{}内的内容只有一行，大括号可以省略，这点和Java的规定一样

　　　　　　2) Scala中任意表达式都是有返回值的，也就意味着if else表达式是有返回结果的，具体返回结果的值取决于满足条件的代码体的最后一行内容

　　　　　　3) Scala中没有三元运算符，因为这样可以简写

　　　　　　案例演示

object boke_demo01 {

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

    var sumVal = 22
    val result =
      if(sumVal > 20){
        "结果大于20"//()
      }
    println("res=" + result) //返回的是() 即 Unit
  }

}

4.4 嵌套分支

　　4.4.1 基本介绍

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

　　4.4.2 基本结构

　　　　　　if(){

　　　　　　　　if(){

　　　　　　　　} else {

　　　　　　　　}

　　　　　　}

4.5 switch分支结构

　　　　　　在Scala中没有switch，而是使用模式匹配来处理 match-case

4.6 for循环控制

　　4.6.1 基本介绍

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

　　4.6.2 范围数据循环方式一

　　　　　　案例演示

object boke_demo01 {

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

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

}

　　　　　　说明：i表示循环的变量，<-规定好to规定，i将会从1－3循环，前后闭合

　　4.6.3 范围数据循环方式二

　　　　　　案例演示

object boke_demo01 {

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

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

}

　　　　　　说明：这种方式和前面的区别在于i是从1到3减1，前闭合后开的范围，和Java的arr.length()类似，for (int i = 0; i < arr.lenght; i++){}

　　4.6.4 循环守卫

　　　　　　案例演示

object boke_demo01 {

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

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

}

　　　　　　案例说明：循环守卫，即循环保护式(也称条件判断式，守卫)，保护式为true则进入循环体内部，为false则跳过，类似于continue

　　　　　　上面的代码等价

object boke_demo01 {

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

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

}

　　4.6.5 引入变量

　　　　　　案例演示

object boke_demo01 {

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

    for(i <- 1 to 3; j = 4 - i) {
      print(j + " ")  // 3,2,1
    }
  }

}

　　　　　　对案例演示的说明：没有关键字，所以范围后一定要加分号来隔断逻辑

　　4.6.6 循环嵌套

　　　　　　案例演示

object boke_demo01 {

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

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

    //上面的写法，可以写成
    println("--------------------------")
    for (i <- 1 to 3) {
      for (j <- 1 to 3) {
        println(" i =" + i + " j = " + j)
      }
    }
  }

}

　　4.6.7 循环返回值

　　　　　　案例演示

object boke_demo01 {

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

    //说明 val res = for(i <- 1 to 10) yield i 含义
    //1. 对1 to 10 进行遍历
    //2. yield i 将每次循环得到i 放入到集合Vector中，并返回给res
    //3. i 这里是一个代码块，这就意味我们可以对i进行处理
    //4. 下面的这个方式，就体现出scala一个重要的语法特点，就是将一个集合中个各个数据
    //    进行处理，并返回给新的集合

    val res = for(i <- 1 to 10) yield {
      if (i % 2 == 0) {
        i
      }else {
        i + "不是偶数"
      }
    }
    println(res)
  }

}

　　4.6.8 使用花括号{}代替小括号()

　　　　　　案例演示

object boke_demo01 {

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

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

    //等价
    println("------------------------")
    for {
      i <- 1 to 3
      j = i * 2} {
      println(" i= " + i + " j= " + j)
    }

  }

}

　　　　　　对案例演示的说明

　　　　　　1) {}和()对于for表达式来说都可以

　　　　　　2) for推导式有一个不成文的约定：当for推导式仅包含单一表达式时使用小括号，当其包含多个表达式时使用花括号

　　　　　　3) 当使用{}来换行写表达式时，分号就不用写了

　　4.6.9 注意事项和细节说明

　　　　　　1) Scala的for循环和Java有较大差异，但是基本的原理还是一样的

　　　　　　2) Scala的for循环的步长是如何控制的[for(i<-Range(1,3,2))]

　　　　　　3) 案例演示

object boke_demo01 {

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

    for (i <- 1 to 10) {
      println("i=" + i)
    }
    //步长控制为2
    println("-------------")
    //Range(1,10,2)的对应的构建方法是
    //def apply(start: Int, end: Int, step: Int): Range = new Range(start, end, step)
    for (i <- Range(1, 10, 2)) {
      println("i=" + i)
    }

    //控制步长的第二种方式-for循环守卫
    println("**************************")
    for (i <- 1 to 10 if i % 2 == 1) {
      println("i=" + i)

    }
  }

}

4.7 while循环控制

　　4.7.1 基本语法

　　　　　　循环变量初始化

　　　　　　while(循环条件){

　　　　　　　　循环体(语句)

　　　　　　　　循环变量迭代

　　　　　　}

　　4.7.2 while循环应用实例

　　　　　　1) 输出10句“你好”

　　　　　　2) 代码如下

object boke_demo01 {

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

    //输出10句 你好,
    //1. 定义循环变量
    var i = 0
    //2. i < 10 条件
    while (i < 10) {
      println("你好," + i) //循环体
      i += 1 //循环变量迭代
    }
  }

}

　　4.7.3 注意事项和细节说明

　　　　　　1) 循环条件是返回一个布尔值的表达式

　　　　　　2) while循环是先判断再执行语句

　　　　　　3) 与if语句不同，While语句本身没有值，即整个While语句的结果是Unit类型的()

　　　　　　4) 因为while中没有返回值，所以当要用该语句来计算并返回结果时，就不可避免的使用变量，而变量需要声明在while循环的外部，那么就等同于循环的内部对外部的变量造成了影响，所以不推荐使用，而是推荐使用for循环。

4.8 do...while循环控制

　　4.8.1 基本语法

　　　　　　循环变量初始化;

　　　　　　do {

　　　　　　　　循环体(语句)

　　　　　　　　循环变量迭代

　　　　　　} while(循环条件)

　　4.8.2 do...while循环应用实例

object boke_demo01 {

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

    //循环输出10句 你好
    var i = 0 // for
    do {
      printf(i + "你好\n")
      i += 1
    } while (i < 10)
  }

}

　　4.8.3 注意事项和细节说明

　　　　　　1) 循环条件是返回一个布尔值的表达式

　　　　　　2) do...while循环是先执行，再判断

　　　　　　3) 和while一样，因为do...while中没有返回值，所以当药用该语句来计算并返回结果时，就不可避免的使用变量，而变量需要声明再do...while循环的外部，那么久等于循环的内部对外部的变量造成了影响，所以不推荐使用，而是推荐使用for循环

4.9 多重循环控制

　　4.9.1 基本介绍

　　　　　　1) 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for，while，do...while均可以作为外层循环和内层循环[建议使用两层，最多不要超过三层]

　　　　　　2) 实质上，就是将内层循环当成外层循环的循环体，只有当内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层循环的当次循环，开始下一次循环

　　　　　　3) 设外层循环次数为m，内层为n次，则内层循环体实际上需要执行m*n=mn次

4.10 while循环的中断

　　4.10.1 基本介绍

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

　　4.10.2 break应用实例

import util.control.Breaks._

object boke_demo01 {

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

    var n = 1
    //breakable()函数
    //说明
    //1. breakable 是一个高阶函数：可以接收函数的函数就是高阶函数（后面详解）

    //2. def breakable(op: => Unit) {
    //    try {
    //      op
    //    } catch {
    //      case ex: BreakControl =>
    //        if (ex ne breakException) throw ex
    //    }
    //  }
    // (1) op: => Unit 表示接收的参数是一个没有输入，也没有返回值的函数
    // (2) 即可以简单理解可以接收一段代码块
    // 3. breakable 对break()抛出的异常做了处理,代码就继续执行
    // 4. 当我们传入的是代码块，Scala程序员会将() 改成{}
    breakable {
      while (n <= 20) {
        n += 1
        println("n=" + n)
        if (n == 18) {
          //中断while
          //说明
          //1. 在Scala中使用函数式的break函数中断循环
          //2. def break(): Nothing = { throw breakException }
          break()
        }
      }
    }

    println("ok~~")

    //注意break函数，可以使用在for或者do..while
    breakable {
      for (i <- 1 to 100) {
        println("i=" + i)
        if (i == 20) {
          break()
        }
      }
    }

    println("ok2~~~~")

  }

}

　　4.10.3 如何实现continue的效果

　　　　　　Scala内置控制结构特地也去掉了continue，是为了更好地适应函数化编程，可以使用if-else或者循环守卫实现continue的效果

　　　　　　案例演示

object boke_demo01 {

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

    //说明
    //1. 1 to 10
    //2. 循环守卫 if (i != 2 && i != 3) 这个条件为ture,才执行循环体
    //   即当i ==2 或者 i == 3时，就跳过
    for (i <- 1 to 10 if (i != 2 && i != 3)) {
      println("i=" + i)
    }

    //也可以写成如下的形式
    println("============================")
    for (i <- 1 to 10) {

      if (i != 2 && i != 3) {
        println("i=" + i)
      }

    }
  }

}