Scala编程学习之四-流程控制语句

1.程序流程控制介绍

在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句。
温馨提示： Scala语言中控制结构和Java语言中的控制结构基本相同，在不考虑特殊应用场景的情况下，代码书写方式以及理解方式都没有太大的区别 [知道-》不会说 ]
1)顺序控制
2)分支控制（单分支, 双分支，多分支）
3)循环控制

2顺序控制

2.1顺序控制介绍

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

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

Scala中定义变量时采用合法的前向引用。如：
def main(args : Array[String]) : Unit = {
var num1 = 12
var num2 = num1 + 2
}
错误形式：
def main(args : Array[String]) : Unit = {
var num2 = num1 + 2
var num1 = 12
}

3.分支控制的if-else

3.1分支控制if-else介绍

让程序有选择的的执行,分支控制有三种:
1)单分支
2)双分支
3)多分支

3.2单分支

3.3双分支

3.4双分支小案例:
判断一个年份是否是闰年，闰年的条件是符合下面二者之一：(1)年份能被4整除，但不能被100整除；(2)能被400整除

object IfElseDemo {
  def main(args: Array[String]): Unit = {
    /*
    判断一个年份是否是闰年，闰年的条件是符合下面二者之一：(1)年份能被4整除，但不能被100整除；(2)能被400整除
    分析
    1. 有一个变量，保存year
    2. 分支控制
    3. (1) 和 (2) 条件是 或的关系
    4. (1) 中的两个条件是 与的关系
    代码
     */

    var year = 2020
    if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
      println("year=" + year + "是闰年")
    } else {
      println("year=" + year + "不是闰年")
    }

  }
}

3.5多分支小案例
岳小鹏参加scala考试，他和父亲岳不群达成承诺：
如果：
成绩为100分时，奖励一辆BMW；
成绩为(80，99]时，奖励一台iphone7plus；
当成绩为[60,80]时，奖励一个 iPad；
其它时，什么奖励也没有。

说明: 成绩在控制台输入!
代码:

 import scala.io.StdIn
    
    object IfElseIf {
      def main(args: Array[String]): Unit = {
        /*
        岳小鹏参加scala考试，他和父亲岳不群达成承诺：
    如果：
    成绩为100分时，奖励一辆BMW；
    成绩为(80，99]时，奖励一台iphone7plus；
    当成绩为[60,80]时，奖励一个 iPad；
    其它时，什么奖励也没有。
    
    说明: 成绩在控制台输入!
        分支
        1. 有一个变量 score 保存我们的成绩
        2. 使用多分支来控制流程
        3. 根据不同的情况，来输出结果
         */
        println("请输入岳小鹏考试成绩")
        val score = StdIn.readFloat() //大数据
        if (score >= 100) {
          println("成绩为100分时，奖励一辆BMW")
        } else if (score > 80 ) {
          println("奖励一台iphone7plus")
        } else if (score >= 60) {
          println("奖励一个 iPad")
        } else {
          println("其它时，什么奖励也没有")
        }
      }
    }

求ax2+bx+c=0方程的根。a,b,c分别为函数的参数，如果：b2-4ac>0，则有两个解；
b2-4ac=0，则有一个解；b2-4ac<0，则无解，结果保留小数点两位. [a=3 b=100 c=6]
提示1：x1=(-b+sqrt(b2-4ac))/2a
               X2=(-b-sqrt(b2-4ac))/2a

提示2：sqrt(num)  在 scala 包中(默认引入的) 的math 的包对象有很多方法直接可用.

代码实现和分析：

object Exercise02 {
  def main(args: Array[String]): Unit = {
    /*
    求ax2+bx+c=0方程的根。a,b,c分别为函数的参数，如果：b2-4ac>0，则有两个解；
b2-4ac=0，则有一个解；b2-4ac<0，则无解，结果保留小数点两位. [a=3 b=100 c=6]
提示1：x1=(-b+sqrt(b2-4ac))/2a
               X2=(-b-sqrt(b2-4ac))/2a

提示2：sqrt(num)  在 scala 包中(默认引入的) 的math 的包对象有很多方法直接可用.
    分析
    1. 定义三个变量 a,b,c
    2. 因为 b2-4ac 的值被使用多次(3次)，就应该保存到变量m，如果是一段功能代码用了3次以上，就封装到类或者方法中()
    3. 多分支
    4. 定义两个值，保存结果(x1,x2)
     */
    //一次性定义三个变量
    val (a, b, c) = (3, 100, 6)
    var (x1, x2) = (0.0, 0.0)
    val m = b * b - 4 * a * c //常用的
    //math是scala包下的一个包对象(简单说包对象指的是，针对给包 scala.math这个包对应对象)
    //1. 即 scala.math 是一个包(package scala.math 等价 package scala package math)，同时还提供了这个scala.math这个包对应的包对象[package object math {]
    if (m > 0) {
      //math.sqrt 这个math就是一个包对象
      x1 = (-b + math.sqrt(m)) / (2 * a)
      x2 = (-b - math.sqrt(m)) / (2 * a)
      println("x1=" + x1.formatted("%.2f"))
      println("x2=" + x2)

    } else if (m == 0) {
      x1 = (-b + math.sqrt(m)) / (2 * a)
      println("x1=" + x1.formatted("%.2f"))

    } else {
      println("没有结果")
    }
  }
}

3.6分支控制if-else 注意事项
1)如果大括号{}内的逻辑代码只有一行，大括号可以省略, 这点和java 的规定一样。
2)Scala中任意表达式都是有返回值的，也就意味着if else表达式其实是有返回结果的，具体返回结果的值取决于满足条件的代码体的最后一行内容.[案例演示]
3)Scala中是没有三元运算符，因为可以这样简写,使用 if – else

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

    //Scala中任意表达式都是有返回值的，也就意味着if else表达式其实是有返回结果的，具体返回结果的值取决于满足条件的代码体的最后一行内容
    //什么是表达式：任何有值的都可以认为是表达式

    val res = if (5 < 3) {
      println("abc") //()
//      "hello"
//      "ok"
    } else {
//      190
//      200
      getSum(10,30) //方法会返回 10 + 30 = 40

    }

    println("res=" + res)
  }

  def getSum(n1:Int,n2:Int): Int = {
    n1 + n2 //返回一个 n1 + n2的值
  }
}

4.嵌套分支

4.1基本介绍

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

4.2基本语法
if(){
if(){
}else{
}
}

4.3应用案例

参加百米运动会，如果用时8秒以内进入决赛，否则提示淘汰。并且根据性别提示进入男子组或女子组。【可以让学员先练习下5min】, 输入成绩和性别，进行判断。1分钟思考思路
double second; char gender;
代码

import scala.io.StdIn

object Exercise03 {
  def main(args: Array[String]): Unit = {
    /*
    参加百米运动会，如果用时8秒以内进入决赛，否则提示淘汰。并且根据性别提示进入男子组或女子组。【可以让学员先练习下5min】, 输入成绩和性别，进行判断
    分析
    1. 有两个变量
    2. 使用到嵌套分支
     */
    println("请输入成绩")
    val second = StdIn.readFloat()
    if (second <= 8 ) {

      println("请输入性别")
      val gender = StdIn.readChar()
      if (gender == '男') {
        println("进入男子组决赛")
      }else {
        println("进入女子组决赛..")
      }

    }else {
      println("你被淘汰...")
    }
  }
}

出票系统：根据淡旺季的月份和年龄，打印票价 [考虑学生先做5min]
scala 没有switch
4_10 旺季：
成人（18-60）：60
儿童（<18）:半价
老人（>60）:1/3

淡季：
成人：40
其他：20
代码

object Exercise04 {
  def main(args: Array[String]): Unit = {
    /*
  分析
  1. 定义月份，年龄，票价
  2. 使用嵌套分支业务处理
     */
    val (month, age, ticket) = (8, 20, 60.0)
    var buyPrice = 0.0
    if (month >= 4 && month <= 10) {
      if (age >= 18 && age <= 60) {
        buyPrice = ticket
      } else if (age < 18) {
        buyPrice = ticket / 2
      } else {
        buyPrice = ticket / 3
      }
    } else {
      if (age >= 18 && age <= 60) {
        buyPrice = 40.0
      } else {
        buyPrice = 20.0
      }
    }
    println("应付" + buyPrice)
  }
}

**

5.switch分支结构

**

在scala中没有switch,而是使用模式匹配(match-case )来处理。后面再写

6.for循环控制

6.1基本介绍
Scala 也为for 循环这一常见的控制结构提供了非常多的特性，这些for 循环的特性被称为for 推导式（for comprehension）或for 表达式（for expression）

6.2范围数据循环方式
基本案例
for(i <- 1 to 3){ // 这里的 1 to 3 也可以是一个集合
print(i + " ")
}
println()
说明
1)i 表示循环的变量， <- 规定好 to 规定
2)i 将会从 1-3 循环， 前后闭合 （包括1 和 3）
输出10句 “hello!”

object ForDemo01 {
  def main(args: Array[String]): Unit = {
    /*
    输出10句 "hello!"

     */
    val n = 10
    for (i <- 1 to n) {
      println("你好" + i) //i 在不断的变化
    }

    //这里 1 to n 也可以直接是一个集合对象
    val list = List("北京", "广州", "深圳")

    for (item <- list) {
      println("item=" + item)
    }
  }
}

6.3范围数据循环方式
基本案例
for(i <- 1 until 3) {
print(i + " ")
}
println()
说明:
1)这种方式和前面的区别在于 i 是从1 到 (3-1)
2)前闭合后开的范围,和java的arr.length() 类似
for (int i =0; i < arr.lenght(); i++ ){}
输出10句 “hello!”

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

    val n = 11
    for (i <- 1 until n ) {
      println("你好" + i)
    }
  }

6.4循环守卫
基本案例
for(i <- 1 to 3 if i != 2) {
print(i + " ")
}
println()

基本案例说明
1)循环守卫，即循环保护式（也称条件判断式，守卫）。保护式为true则进入循环体内部，为false则跳过，类似于continue
2)上面的代码等价
for (i<-1 to 3){
if ( i != 2) {
println(i+" ")
}
}
案例

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

    //说明
    //i 变量名不是固定，是程序员指定
    //但是前后要一致
    for (i <- 1 to 3 if i != 2) {
      println("i=" + i) // 1 3
    }

    //集合进行遍历，使用循环守卫
    val list = List("bj", "tj", "sz")
    for (item <- list if item.startsWith("b")) {
      println("item=" + item)
    }
  }

6.5引入变量
基本案例
for(i <- 1 to 3; j = 4 - i) {
print(j + " ")
}

对基本案例说明
1)没有关键字，所以范围后一定要加；来隔断逻辑
2)上面的代码等价
for (i <- 1 to 4) {
val j = 4 - i
println(s"i=$ij=${j}")
}
代码案例

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

    //说明
    //1.; 不能去掉

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

    println("================")
    //等价
    for (i <- 1 to 4) {
      val j = 4 - i
      println(s"i=${i} j=${j}")
    }

  }
}

6.6嵌套循环
基本案例
for(i <- 1 to 3; j <- 1 to 3) {
println(" i =" + i + " j = " + j)
}

对基本案例说明
1)没有关键字，所以范围后一定要加；来隔断逻辑
2)上面的代码等价(处理比较复杂的业务时，使用这个)
for (i <- 1 to 3) {
for (j <-1 to 3) {
println(“ok”)
}
}
代码

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

    for (i <- 1 to 3; j <- 1 to 3) {
      println(s"i=$i  j=$j")
    }
    //等价的写法
    println("================")
    for (i <- 1 to 3) {
      for (j <- 1 to 3) {
        println(s"i=$i  j=$j")
      }

    }
  }

6.7循环返回值
基本案例
val res = for(i <- 1 to 10) yield i * 2
println(res)

对基本案例说明
将遍历过程中处理的结果返回到一个新Vector集合中，使用yield关键字，yield 可以写代码块.
代码

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

    val res = for (i <- 1 to 10) yield  (i * 2)
    println("res=" + res)

    //将1到10数中的奇数放入到新的集合

    val res2 = for (i <- 1 to 10) yield  {
      if (i % 2 == 1) {
        i
      }else {
        ()
      }
    }

    println("res2=" + res2)

  }

6.8使用花括号{}代替小括号()
基本案例
for(i <- 1 to 3; j = i * 2) {
println(" i= " + i + " j= " + j)
}
可以写成:

对基本案例说明
1){}和()对于for表达式来说都可以
2)for 推导式有一个不成文的约定：当for 推导式仅包含单一表达式时使用圆括号，当其包含多个表达式时使用大括号
3)当使用{} 来换行写表达式时，分号就不用写了
4)代码：

object ForDemo03 {
  def main(args: Array[String]): Unit = {
    for {i <- 1 to 3
         j = i * 2} {
      println(" i= " + i + " j= " + j)
    }

  }

6.9注意事项和细节说明[控制步长]

1)scala 的for循环形式和java是较大差异，这点请同学们注意，但是基本的原理还是一样的。
2)scala 的for循环的步长如何控制! [for(i <- Range(1,3,2)]
3)思考题：如何使用循环守卫控制步长
4)代码实现

object ForStep {
  def main(args: Array[String]): Unit = {
    //遍历 1-10, 步长为 3
    //方式1 使用Range, 他是一个集合
    //说明 1： start
    //     10: end 遍历到(end -1)
    //      3: 表示step
    for (i <- Range(1,10,3)) { //until
      println("i=" + i)
    }

    //灵活的使用守卫 [推荐]
    println("==========使用守卫控制步长==============")
    for (i <- 1 to 10 if i % 3 == 1 ) {
      println("i=" + i)
    }
  }

6.10for循环小练习

object Exercise05 {
  def main(args: Array[String]): Unit = {
    //打印1~100之间所有是9的倍数的整数的个数及总和
    val start = 1
    val end = 100
    var sum = 0
    var count = 0
    for (i <- start to end) {
      if (i % 9 == 0) {
        count += 1
        sum += i
      }
    }
    printf("count=%d sum=%d\n", count, sum)

    //完成下面的表达式输出

    val n = 6
    for (i <- 0 to n) {
      printf("%d + %d = %d\n", i, (n - i), n)
    }

  }

7.while循环

7.1基本语法
循环变量初始化 //循环的四个要素
while (循环条件) {
循环体(语句)
循环变量迭代
}

7.2while循环应用实例

画出流程图
输出10句"你好,世界"
代码：

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

    //输出10 hello
    var n = 1
    while (n <= 10) {
      println("hello,world" + n)
      n += 1 //循环遍历的迭代
    }
  }

7.3注意事项和细节说明

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

8.do…while循环控制

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

8.2do…while循环应用实例

画出流程图
输入10 “你好,世界”

object DoWhile {
  def main(args: Array[String]): Unit = {
    //统计1——200之间能被5整除但不能被3整除的个数
    //do..while 循环的四要素
    var n = 1
    var max = 200
    var count = 0
    do {
      if (n % 5 == 0 && n % 3 != 0) {
        count += 1
      }
      n += 1
    }while(n <= max)
    println("count=" + count)
  }

8.3实例：

1)统计三个班成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。
2)统计三个班及格人数，每个班有5名同学。
3)代码

import scala.io.StdIn

object Exercise06 {
  def main(args: Array[String]): Unit = {
    /*
    1统计三个班成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均    分[学生的成绩从键盘输入]。
    2.统计三个班及格人数，每个班有5名同学。

   思路分析
   1. 定义变量 classNum , stuNum ,  classTotalScore, totalScore, passStuNum
   2. 因为没有数组，所以每次输入完一个班级的成绩后，就立即得到结果
   3. 会使用到嵌套循环.
     */
    val classNum = 3
    val stuNum = 5
    var classTotalScore = 0.0
    var totalScore = 0.0
    var stuScore = 0.0
    var passStuNum = 0

    for (i <- 1 to classNum) {//遍历三个班
      //将班级成绩清0.0
      classTotalScore = 0.0
      for (j<-1 to stuNum) {//遍历学生
        printf("请输入%d班级的第%d个学生的成绩\n" , i, j)
        stuScore = StdIn.readDouble()

        //累计及格的学生个数
        if (stuScore >= 60) {
          passStuNum += 1
        }
        //累计到 classTotalScore
        classTotalScore += stuScore
      }
      //得到班级的总成绩
      printf("第%d个班的平均成绩为%.2f\n", i, classTotalScore / stuNum)
      //累计到totalScore， 为了计算所有班级的总成绩
      totalScore += classTotalScore
    }
    //统计所有班级的平均分
    printf("总有班级的平均分为%.2f\n", totalScore / (classNum * stuNum))
    printf("及格的人数有%d\n", passStuNum)


  }

9.scala循环的中断使用

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

// _ 类似 java中的 * 表示 将 包中的内容（class, object,trait,package object）引入进来
import util.control.Breaks._
object BreakDemo {
  def main(args: Array[String]): Unit = {
    //看看scala中的break机制.
    //先看代码，再做分析[看源码]

    //breakable
    //1. breakable 是一个 def 函数/
    /*
     def breakable(op: => Unit) {
    try {
      op
    } catch {
      case ex: BreakControl =>
        if (ex ne breakException) throw ex
    }
  }
     */
    //2. breakable 是一个函数，而且是一个高阶函数
    //3. 简单的说一下, 在scala中 高阶函数就是可以接收函数作为参数的函数，而且还可以返回函数
    //4. op: => Unit 表示他接收的函数是，没有输入参数，也没有输出的函数
    //5. op 表示的就是接收到函数的参数名
    //6. op 执行传入函数
    breakable {
      var n = 1
      while (true) {
        println("n=" + n)
        n += 1
        if (n == 18) {
          //说明 看break（）
          //def break(): Nothing = { throw breakException } 抛出breakException
          break() //默认会直接让程序崩溃
        }
      }
    }

    println("ok~~")


    f1(sayHi) //
    f1{
      sayHi // {}
    }

    f1 {
      println("say Hi~~")
    }
  }

  //我模拟一段高阶函数的代码

  def sayHi(): Unit = {
    println("say Hi~~")
  }

  //f1就是一个高阶函数，可以接收一个函数【没有输入参数，没有输出的函数比如 sayHi】
  def f1(op: => Unit): Unit = {
    op
  }

案例2

 object ForBreak {
      def main(args: Array[String]): Unit = {
    
        //在for循环中，仍然使用break() 中断
        breakable {
          for (i <- 1 to 900000) {
            if (i == 99) {
              break()
            }
            println("i=" + i)
          }
        }
    
        println("程序继续....")
      }

9.3关于循环中断的应用案例
题目要求
100以内的数求和，求出当和 第一次大于20的当前数是多少？【for】
请使用循环守卫和breakable，完成break的效果？
代码实现

import util.control.Breaks._

object BreakExercise {
  def main(args: Array[String]): Unit = {
    //100以内的数求和，求出当和 第一次大于20的当前数是多少
    //推荐
    val max = 100
    var sum = 0
    breakable {
      for (i <- 1 to max) {
        sum += i //累计
        if (sum > 20) {
          println("传统的breakable() 当前i=" + i)
          break()
        }
      }
    }

    //使用循环守卫完成 上面的题
    sum = 0
    var flag = true
    for (i <- 1 to max if flag == true) {
      sum += i
      if (sum > 20) {
        println("使用的是循环守卫机制 当前的i=" + i)
        flag = false
      }
    }

  }