四、Scala从入门到精通一一循环控制

1、 程序的流程控制说明

在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句。
1、顺序控制
2、分支控制
3、循环控制

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、单分支的使用

基本语法
if (条件表达式) {
执行代码块
}
说明：当条件表达式为ture 时，就会执行 { } 的代码
案例说明：
编写一个程序，可以输入人的年龄,如果该同志的年龄大于18岁,则输出 “age > 18”

val age = 20
if (age > 18) {
println("age > 18")
}

单分支对应的流程图：

3.3、双分支的使用

基本语法
if (条件表达式) {
执行代码块1
} else {
执行代码块2
}
说明：当条件表达式成立，即执行代码块1，否则执行代码块2.
案例说明：
编写一个程序,可以输入人的年龄,如果该同志的年龄大于18岁,则输出 “age >18”。否则 ,输出 "age <= 18 "

val age = StdIn.readInt()
if (age > 18) {
  println("age > 18")
}else{
  println("age <= 18")
}

双分支对应的流程图：

3.4、单分支双分支练习题

1. 对下列代码，若有输出，指出输出结果。

var x = 4
var y = 1
if (x > 2) {
       if (y > 2) {
                println(x + y)
      }
                println("teacher")  // 输出内容 teacher
} else
       println("x is " + x)

3.5、单分支和双分支课后题

1、编写程序，声明2个Int型变量并赋值。判断两数之和，如果大于等于50，打印“hello world!”

val a:Int = 11
val b:Int = 40
if ((a+b)>50) println("hello world!")

2、编写程序，声明2个Double型变量并赋值。判断第一个数大于10.0，且第2个数小于20.0，打印两数之和。

val a = 11.0
val b = 10.0
if (a > 10.0 && b < 20.0) {
println(a + b)
} else {
println("条件不满足")
}

3、【选作】定义两个变量Int，判断二者的和，是否既能被3又能被5整除，打印提示信息

val num1 = 10
val num2 = 2
val sum = num1 + num2
if (sum % 3 == 0 && sum % 5 == 0) {
println("能被3又能被5整除")
} else {
println("能被3又能被5整除,不成立~")
}

4、判断一个年份是否是闰年，闰年的条件是符合下面二者之一：(1)年份能被4整除，但不能被100整除；(2)能被400整除

val year = 2020
if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {
println(s"${year} 是闰年...")
}else{
println(s"${year} 不是闰年...")
}

3.6 多分支

基本语法
if (条件表达式1) {
执行代码块1
}
else if (条件表达式2) {
执行代码块2
}
……
else {
执行代码块n
}
多分支的流程图：

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

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

println("请输入成绩：")
val score = StdIn.readDouble()
if (score == 100) {
  println(" 成绩为100,奖励一台BMW")
} else if (score > 80 && score <= 99) { // 写法1 使用范围 ， 写法2 就是严格的判断
  println("成绩为{80,99}，奖励一台iPhone 11")
} else if (score >= 60 && score <= 80) {
  println("成绩为{60，80}时，奖励一个Ipad")
} else {
  println("什么奖励也没有")
}

案例演示2：
求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 的包对象有很多方法直接可用.

val a = 3
val b = 100
val c = 6
val m = b * b - 4 * a * c
var x1 = 0.0
var x2 = 0.0
if (m > 0) {
  x1 = (-b + sqrt(m)) / 2 * a
  x2 = (-b - sqrt(m)) / 2 * a
  println(s"方程有两个解，分别是x1=${x1.formatted("%.2f")},x2=${x2.formatted("%.2f")}")
} else if (m == 0) {
  x1 = (-b + sqrt(m)) / 2 * a
  println("方程有两个解，分别是x1=$x1")
} else {
  println("方程无解")
}

3.7、分支控制if-else 注意事项

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

val result = if (flg) 1 else 0  
 // 因为 scala 的if-else 是有返回值的，因此，本身这个语言也不需要三元运算符了(如图)，并且可以写在同一行，类似 三元运算

4、看下面案例，判断输出什么

object Hello01 {
def main(args: Array[String]): Unit = {
var sumVal = 9    
val result =    
if(sumVal > 20){
"结果大于20"
   }
println(result) // Unit ()

4、嵌套分支

4.1、基本介绍

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

4.2、基本语法

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

4.3、应用案例

1、参加百米运动会，如果用时8秒以内进入决赛，否则提示淘汰。并且根据性别提示进入男子组或女子组。输入成绩和性别，进行判断。

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

    /*
    参加百米运动会，如果用时8秒进入决赛，否知提示淘汰，并且根据性别提示进入男子组或女子组，
    [可以让学员先练习一下5min]，输入成绩和性别，进行判断
     */
    println("请输入运动员的成绩:")
    val speed = StdIn.readDouble()
    if (speed <= 8){
      println("请输入你的性别:")
      val gender = StdIn.readChar()
      if (gender == '男'){
        println("进入男子组")
      }else{
        println("进入女子组")
      }
    }else{
      println("你被淘汰了....")
    }
  }
}

2、出票系统：根据淡旺季的月份和年龄，打印票价
4_10 旺季：
成人（18-60）：60
儿童（<18）:半价
老人（>60）:1/3

淡季：
成人：40
其他：20

object Exercise05 {
  def main(args: Array[String]): Unit = {
    println("输入月份:")
    val month = StdIn.readInt()
    println("输入年龄：")
    val age = StdIn.readInt()
    val tikcet = 60
    if (month >= 4 && month <= 10) {
      if (age > 18 && age <= 60) {
        println("你的票价是：" + tikcet)
      } else if (age < 18) {
        println("你的票价是：" + tikcet / 2)
      } else {
        println("你的票价是：" + tikcet / 3)
      }
    } else {
      if (age > 18 && age <= 60) {
        println("你的票价为：" + 40)
      } else {
        println("你的票价为：" + 20)
      }
    }
  }
}

5、Switch分支结构

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

6、for循环控制

6.1、基本介绍

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

6.2、范围数据循环方式1

基本案例
for(i <- 1 to 3){
print(i + " ")
}
println()
说明
1、i 表示循环的变量， <- 规定好 to 规定
2、i 将会从 1-3 循环， 前后闭合

6.3、范围数据循环方式2

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

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

6.5、引入变量

基本案例
for(i <- 1 to 3; j = 4 - i) {
print(j + " ")
}
对基本案例说明
1、没有关键字，所以范围后一定要加；来隔断逻辑
2、上面的代码等价
for ( i <- 1 to 3)
{
val j = 4 –i
print(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 <- 1to 3){
println(i + " " + j + " ")
}
}

6.7、循环返回值

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

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

6.8、使用{}代替()

基本案例
for(i <- 1 to 3; j = i * 2) {
println(" i= " + i + " j= " + j)
}
可以写成
for{
i <- 1 to 3
j = i * 2} {
println(" i= " + i + " j= " + j)
}
对基本案例说明
1、{}和()对于for表达式来说都可以
2、for 推导式有一个不成文的约定：当for 推导式仅包含单一表达式时使用圆括号，当其包含多个表达式时使用大括号
3、当使用{} 来换行写表达式时，分号就不用写了

6.9、注意事项和细节说明

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

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

6.10、for循环练习题

1、打印1~100之间所有是9的倍数的整数的个数及总和.
2、完成下面的表达式输出

/*
1、打印1~100 之间所有是9的倍数的整数的个数及总和
 */
val start = 1
val end = 100
var count = 0
var sum = 0
for (i <- start to end){
  if (i%9==0){
    count += 1
    sum += i
  }
}
printf("count=%d,sum=%d\n",count,sum)

/*
  2、输出加法的循环表达式
 */
val num = 6
for (i<- 0 to num){
  printf("%d + %d = %d",i,(num-i),num)
  println()
}

7、While循环控制

7.1、基本语法

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

7.2、While循环应用实例

1、输出10句"Hello，world"

var i = 0
while (i < 10) {
  println(i + "、" + "Hello,world")
  // 循环遍历迭代
  i += 1
}

7.3、注意事项和细节说明

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

7.4、练习题

1、打印1—100之间所有能被3整除的数

var i = 1
while (i < 101) {
  if (i % 3 == 0) {
    println("i=" + i)
  }
  i += 1
}

2、打印40—200之间所有的偶数

var b = 40
while (b < 201) {
  if (b % 2 == 0) {
    println("b=" + b)
  }
  b += 1
}

8、do-While循环控制

8.1、基本语法

8.2、do-while循环应用实例

输出10 “hello，world”

var i = 1
do {
  println(i+"、"+"Hello,world")
  i += 1
} while (i < 11)

8.3、注意事项和细节说明

1、循环条件是返回一个布尔值的表达式
2、do…while循环是先执行，再判断
3、和while 一样，因为do…while中没有返回值,所以当要用该语句来计算并返回结果时,就不可避免的使用变量 ，而变量需要声明在do…while循环的外部，那么就等同于循环的内部对外部的变量造成了影响，所以不推荐使用，而是推荐使用for循环

8.4、练习题

1、计算1—100的和

var i = 1
  var sum = 0
  do {
    sum += i
    i += 1
  } while (i < 101)
  printf("1-100的和=%d", sum)

2、统计1——200之间能被5整除但不能被3整除的个数

  var d = 1
  var count = 0
  do {
    if (d % 5 == 0 && d % 3 != 0) {
      count += 1
    }
    d += 1
  } while (d < 201)
  println("统计1-200之间能被5整除但不能被3整除的个数=" + count)

9、多重循环控制

9.1、介绍：

1、将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while均可以作为外层循环和内层循环。【建议一般使用两层，最多不要超过3层】
2、实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
3、设外层循环次数为m次，内层为n次， 则内层循环体实际上需要执行m*n=mn次。

9.2、应用实例

1、统计三个班成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。

  println("班级个数:")
  val classNum = 3
  val stuNum = 5
  var score = 0.0 // 分数
  var classScore = 0.0 // 班级的总分
  var totalScore = 0.0 // 所有班级的总分
  for (i <- 1 to classNum) {
    // 先将classScore ，清0
    classScore = 0.0
    for (j <- 1 to stuNum) {
      printf("请输入第%d的班级的第%d学生的成绩:\n", i, j)
      score = StdIn.readDouble()
      classScore += score
    }
    // 累计总分 totalScore
    totalScore += classScore
    printf("第%d班级的平均分为%.2f\n", i, classScore / stuNum)
  }
  printf("所有班级的平均分为%.2f\n",totalScore/(stuNum*classNum))

2、统计三个班及格人数，每个班有5名同学。

def main(args: Array[String]): Unit = {
  println("班级个数:")
  val classNum = 3
  val stuNum = 5
  var score = 0.0 // 分数
  var classScore = 0.0 // 班级的总分
  var totalScore = 0.0 // 所有班级的总分
  var passNum = 0 // 统计及格人数
  for (i <- 1 to classNum) {
    // 先将classScore ，清0
    classScore = 0.0
    for (j <- 1 to stuNum) {
      printf("请输入第%d的班级的第%d学生的成绩:\n", i, j)
      score = StdIn.readDouble()
      if (score>=60){
        passNum+=1
      }
      classScore += score
    }
    // 累计总分 totalScore
    totalScore += classScore
    printf("第%d班级的平均分为%.2f\n", i, classScore / stuNum)
  }
  printf("所有班级的平均分为%.2f\n", totalScore / (stuNum * classNum))
  printf("所有班级的及格人数为%d\n",passNum)

3、打印出九九乘法表

val num = 9
for (i <- 1 to num){ // 确定行数
  for (j<- 1 to i ){ //确定列数
    printf("%d * %d = %d\t",j,i,i*j)
  }
  println()
}

10、While循环的中断

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

import util.control.Breaks._
// 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程序会会将()改为{}
var n = 1
breakable{
  while (n <= 20) {
    n += 1
    println("n=" + n)
    if (n == 18) {
      // 中端while
      // 说明
      // 1、在Scala中使用函数式的break函数中端循环
      //  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········")

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

continue案例演示：

// 说明
// 1. 1 to 10
// 2. 循环守卫 if (i != 2 && i != 3) 这个条件为真才执行循环体
//    即当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)
  }
}

11、练习题

课后练习题：

1、100以内的数求和，求出当和 第一次大于20的当前数【for】

var sum = 0
breakable {
  for (i <- 1 to 100) {
    sum += i
    if (sum > 20) {
      println("和第一次大于20的当前数:" + s"第${i}次" + sum)
      break()
    }
  }
}
// 除了上面break机制来中端，我们也可以使用循环守卫实现中断
println("·····································")
var loop = true
var sum2 = 0
for (i <- 1 to 100 if loop == true) {
  sum2 += i
  if (sum2 > 20) {
    println("和第一次大于20的当前数:" + s"第${i}次" + sum2)
    loop = false
  }
  println("i=" + i)
}

2、实现登录验证，有三次机会，如果用户名为”张无忌” ,密码”888”提示登录成功，否则提示还有几次机会，请使用for 循环完成

var c = 3
val name = "张无忌"
val password = 888
var Stdname = ""
var Stdpassword = 0
var count = 3
breakable {
  for (i <- 1 to 3) {
    println("请输入用户名：")
    Stdname = StdIn.readLine()
    println("请输入密码:")
    Stdpassword = StdIn.readInt()
    if (Stdname == name && Stdpassword == password) {
      println("登录成功")
      break()
    } else {
      count -= 1
      println("登录失败")
      println(s"机会还有${count}次")
    }
  }
}

3. 某人有100,000元,每经过一次路口，需要交费,规则如下:
   当现金>50000时,每次交5%
   当现金<=50000时,每次交1000
   编程计算该人可以经过多少次路口

var money: Double = 100000
var count = 0
while (money > 50000) {
  if (money > 50000) {
    money = money * 0.95
    count += 1
  }else{
    money = money - 1000
    count += 1
  }
}
println("该人可以经过多少次路口:"+count)