Scala（四）流程控制

4.1 分支控制if-else

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

　　块表达式：

　　　　1） 基本语法:

{
    代码块
}

　　　　2）块表达式有返回值，返回值为{}中最后一个表达式的结果值

4.1.1 单分支

　　1）基本语法

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

　　　　说明：当条件表达式为ture时，就会执行{ }的代码。

　　2）案例实操

　　　　需求：输入人的年龄，如果该同志的年龄大于等于18岁，则输出“18岁，成年了”

package com.yuange.scala.day01

import scala.io.StdIn

object SingleBranch {
  def main(args: Array[String]): Unit = {
    println("请输入年龄：")
    var age = StdIn.readShort()

    if (age >= 18){
      println("18岁，成年了")
    }
  }
}

4.1.2 双分支

　　1）基本语法

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

　　2）案例实操

　　　　需求：输入年龄，如果年龄大于18岁，则输出“age >18”。否则，输出“age <= 18”。

package com.yuange.scala.day01

import scala.io.StdIn

object DoubleBranch {
  def main(args: Array[String]): Unit = {
    println("请输入年龄：")
    var age = StdIn.readShort()

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

4.1.3 多分支

　　1）基本语法

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

　　2）案例实操

　　　　（1）需求：岳小鹏参加Scala考试，他和父亲岳不群达成承诺：如果，成绩为100分时，奖励一辆BM；成绩为(80，99]时，奖励一台iphone；其它时，什么奖励也没有。

package com.yuange.scala.day01

import scala.io.StdIn

object MultiBranchOne {
  def main(args: Array[String]): Unit = {
    println("请输入成绩：")
    var score = StdIn.readInt()

    if (score == 100){
      println("奖励一辆BM")
    }else if (score > 80 && score <= 90){
      println("奖励一台iphone")
    }else{
      println("没有奖励")
    }
  }
}

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

package com.yuange.scala.day01

import scala.io.StdIn

object MultiBranchTwo {
  def main(args: Array[String]): Unit = {
    println("请输入年龄：")
    var age = StdIn.readInt()

    var result = if(age >= 18){
      "成年了"
    }else{
      "乳臭未干"
    }
    println(result)
  }
}

　　　　（3）注意：如果大括号{}内的逻辑代码只有一行，大括号可以省略。Scala中是没有三元运算符，因为可以这样简写

package com.yuange.scala.day01

object MultiBranchThree {

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

    //scala
    var flag : Boolean = true
    var result = if (flag) 1 else 0
    println(result)
  }
}

4.2 嵌套分支

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

　　1）基本语法

if(){
        if(){
           }else{
        }
}

　　2）案例实操

　　　　参加百米运动会，根据性别提示进入男子组或女子组。如果是女子组，用时8秒以内进入决赛，否则提示淘汰。

package com.yuange.scala.day01

import scala.io.StdIn

object NestedBranch {
  def main(args: Array[String]): Unit = {
    println("请输入性别：")
    var sex = StdIn.readChar()

    if (sex == '男'){
      println("进入男子组")
    }else if (sex == '女'){
      println("进入女子组")
      println("请输入成绩：")
      var score = StdIn.readDouble()

      if (score < 8.0){
        println("成绩8秒以内进入决赛")
      }else{
        println("您已淘汰")
      }
    }else{
      println("您是太监吗？")
    }
  }
}

4.3 Switch分支结构

　　在Scala中没有Switch，而是使用模式匹配来处理。模式匹配涉及到的知识点较为综合，因此我们放在后面讲解。

4.4 For循环控制

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

4.4.1 范围数据循环方式1

　　1）基本语法

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

　　　　（1）i 表示循环的变量，<- 规定to

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

　　2）案例实操

　　　　需求：输出10句 "卢本伟牛逼！！！"

package com.yuange.scala.day01

object ForLoopOne {
  def main(args: Array[String]): Unit = {
    for (i <- 1 to 10){
      println("卢本伟牛逼！！！")
    }
  }
}

4.4.2 范围数据循环方式2

　　1）基本语法

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

　　　　（1）这种方式和前面的区别在于i是从1到3-1，即从1到2

　　　　（2）即使前闭合后开的范围

　　2）案例实操

　　　　需求：输出10句 "卢本伟牛逼！！！"

package com.yuange.scala.day01

object ForLoopTwo {
  def main(args: Array[String]): Unit = {
    for (i <- 1 until 11){
      println("卢本伟牛逼!!!")
    }
  }
}

4.4.3 循环守卫

　　1）基本语法

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

}
println()

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

　　　　（2）上面的代码等价

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

　　2）案例实操

　　　　需求：输出1到10中，不等于5的值

package com.yuange.scala.day01

object ForLoopThree {
  def main(args: Array[String]): Unit = {
    for (i <- 1 to 10 if i != 5){
      println("不等于5的值为：" + i)
    }
  }
}

4.4.4 循环步长

　　1）基本语法

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

　　　　说明：by表示步长

　　2）案例实操

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

package com.yuange.scala.day01

object ForLoopFour {
  def main(args: Array[String]): Unit = {
    for (i <- 1 to 10 by 2){
      println("1到10的所有奇数有：" + i)
    }
  }
}

4.4.5 嵌套循环

　　1）基本语法

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

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

　　2）上面的代码等价

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

4.4.6 引入变量

　　1）基本语法

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

　　2）上面的代码等价于

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

4.4.7 循环返回值

　　1）基本语法

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

　　　　说明：将遍历过程中处理的结果返回到一个新Vector集合中，使用yield关键字

　　2）案例实操

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

package com.yuange.scala.day01

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

4.5 While循环控制

　　1）基本语法

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

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

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

　　　　（3）与if语句不同，while语句没有返回值，即整个while语句的结果是Unit类型()

　　　　（4）因为while中没有返回值，所以当要用该语句来计算并返回结果时，就不可避免的使用变量，而变量需要声明在while循环的外部，那么就等同于循环的内部对外部的变量造成了影响，也就违背了函数式编程的重要思想（输入=>函数=>输出，不对外界造成影响），所以不推荐使用，而是推荐使用for循环。

　　2）案例实操

　　　　需求：输出10句 "药水哥对宁说：宁配吗？？？"

package com.yuange.scala.day01

object WhileLoop {
  def main(args: Array[String]): Unit = {
    var i : Int = 1
    while (i <= 10){
      println("药水哥对宁说：宁配吗？？？")
      i += 1
    }
  }
}

4.6 do..while循环控制

　　1）基本语法

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

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

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

　　2）案例实操

　　　　需求：输出10句 "宁看我！那我也看宁！！！"

package com.yuange.scala.day01

object DoWhileLoop {
  def main(args: Array[String]): Unit = {
    var i : Int = 1
    do {
      println("宁看我！那我也看宁！！！")
      i += 1
    }while(i <= 10)
  }
}

4.7 多重循环控制

　　1）基本说明

　　　　（1）将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for，while，do…while均可以作为外层循环和内层循环。【建议一般使用两层，最多不要超过3层】

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

　　　　（3）设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。

　　2）案例实操

　　　　需求：打印出九九乘法表（以下是其中的两种写法，仅供参考）

package com.yuange.scala.day01

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

package com.yuange.scala.day01

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

4.8 While循环中断

　　1）基本说明

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

　　2）案例实操

　　　　需求一：循环遍历10以内的所有数据，数值为5，结束循环（break）

package com.yuange.scala.day01

import util.control.Breaks._

object WhileLoopBreakOne {
  def main(args: Array[String]): Unit = {
    var n = 1
    breakable{
      while(n < 10){
        println("n=" + n)
        n += 1

        if (n == 5){
          break()
        }
      }
    }
    println("退出!")
  }
}

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

package com.yuange.scala.day01

import util.control.Breaks._

object WhileLoopBreakTwo {
  def main(args: Array[String]): Unit = {
    var n = 0
    while (n < 10){
      breakable{
        n += 1
        if (n % 2 != 0){
          println(n)
        }else{
          println("continue")
          break()
        }
      }
      println("退出!")
    }
  }
}

　　3）注意事项

　　　　（1）break：breakable放在循环外

　　　　（2）continue：breakable放在循环内