Scala学习系列（六）流程控制语句

一.程序流程控制介绍

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

二.顺序控制

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
}

三.分支控制的if-else

3.1分支控制if-else介绍

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

3.2单分支

基本语法

if (条件表达式) {   

 执行代码块 }

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

3.3双分支

基本语法    

 if (条件表达式) {     

执行代码块1       } else {   

 执行代码块2       }

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

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；
   其它时，什么奖励也没有。

   说明: 成绩在控制台输入!
       分支
       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("什么奖励也没有")
    }

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

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

四.嵌套分支

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

五.switch分支结构

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

六.for循环控制

6.1基本介绍

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

 

6.2范围数据循环方式

如代码所示：

package com.zpark.bigdata.scala.chapter04

object Scala03_For {
  def main(args: Array[String]): Unit = {
    // TODO Java中for循环
    /*
    for (int i = 0;i<10;i++){
      循环体
    }

    for (String s : strings ) {
      循环体
    }
   */
    // TODO Scala中for循环

    //使用 1to5 表示循环的范围，1到5。  1.to(5) -->  对象.方法
    for(i <- 1 to 5){
      println(s"i = ${i}")
    }
    //使用 1until5 表示循环的范围，1截止到5（不包含5）。  1.until(5) -->  对象.方法
    for(i2 <- 1 until 5){
      println(s"i2 = ${i2}")
    }
    //Range(start,end,step)  step：以2个增长模式增加
    for (i3<-Range (1,5,2)){
      println(s"i3 = ${i3}")
    }
//嵌套循环
    for(i1<-1 to 3){
      for(j<- 1 until 3){
        println(s"${i1} = ${j}")
      }
    }

    //九成妖塔
    for(i <- Range(1,18,2)){
      println(" "*((18-i)/2)+ "*"*i+" "*((18-i)/2))
    }
  }
  }
}

6.3循环守卫

所谓循环守卫就是增加条件判断，如果条件成立，那么执行循环体，如果不成立，跳过循环体

基本案例
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+" ")
   }
}

6.4引入变量

基本案例
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= {i} j=ij={j}")
}
也可以写成(scala中推荐使用)

for{i <- 1 to 4

j=4-i} {

println(s"i=ij= {i} j=ij={j}")

}

 

6.5嵌套循环

基本案例
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.6循环返回值

基本案例
val res = for(i <- 1 to 10) yield i * 2
println(res)

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

//循环返回值
    //默认情况下，for循环的返回值为()

    //TODO 特殊情况采用yield关键字,表示把每一次循环的结果放到集合当中返回
    val res = for(i <- 1 to 10) yield i * 2
    println(res)

 

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

基本案例
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.8注意事项和细节说明[控制步长]

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.9中断循环

直接上代码：

//中断循环
    //Java中采用的是break语法
    //Scala中没有break关键字，但是她可以采用对象的方式来中断循环
    //Breaks.breakable{}  它的作用就是将可能抛异常的放在括号里，这样不会中断代码，还会继续运行下边的。类似于try..cath
    Breaks.breakable{
      for(i <- 1 to 10){
        if (i == 5){
          Breaks.break()
        }
        println(s"${i}")
      }
    }
   println("循环终止")

第二种方法：

// TODO import scala.util.control.Breaks._   加上._后,原来的Breaks就可以省略了，直接写成如下代码


    breakable{
      for(i <- 1 to 10){
        if (i == 5){
          break()
        }
        println(s"${i}")
      }
    }
   println("循环终止")

七.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循环，就先考虑使用.)

八.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.循环条件是返回一个布尔值的表达式

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

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

8.4实例：

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)


  }

九.多重循环控制

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

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

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