第 4 章流程控制

4.1 分支控制if-else

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

4.1.1 单分支

1）基本语法

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

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

2）案例实操

需求：输入人的年龄，如果该同志的年龄小于 18 岁，则输出“童年”

package com.neuedu.chapter04

import scala.io.StdIn
;

/**
 * @auth 金山老师
 * title:   书籍代码
 * creatime: 2022-10-22 15:48
 * 描述 :
 */
object Test01_IF {

    //需求：输入人的年龄，如果该同志的年龄小于 18 岁，则输出“童年”
    def main(args: Array[String]): Unit = {

        print("请输入您的年龄:")
        val age = StdIn.readInt()
        if(age < 18){
            println("童年")
        }


    }

}

4.1.2 双分支

1）基本语法

scala

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

2）案例实操

需求：输入年龄，如果年龄小于 18 岁，则输出“童年”。否则，输出“成年”。

scala

package com.neuedu.chapter04

import scala.io.StdIn
;

/**
 * @auth 金山老师
 * title:   书籍代码
 * creatime: 2022-10-22 15:48
 * 描述 :
 */
object Test01_IF {

    //需求：输入人的年龄，如果该同志的年龄小于 18 岁，则输出“童年”
    def main(args: Array[String]): Unit = {

        print("请输入您的年龄:")
        val age = StdIn.readInt()
        if(age < 18){
            println("童年")
        }else{
            println("成年")
        }


    }

}

4.1.3 多分支

1）基本语法

scala

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

2）案例实操

（1）需求 1：需求：输入年龄，如果年龄小于 18 岁，则输出“童年”。如果年龄大于等于 18 且小于等于 30，则输出“中年”，否则，输出“老年”。

scala

package com.neuedu.chapter04

import scala.io.StdIn

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

    println("input age")
    var age = StdIn.readInt()

    if (age < 18) {
      println("童年")
    } else if (age >= 18 && age < 30) {
      println("中年")
    } else {
      println("老年")
    }
  }
}

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

scala

package com.neuedu.chapter04

import scala.io.StdIn

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

    println("input age")
    var age = StdIn.readInt()

    val res: String = if (age < 18) {
      "童年"
    } else if (age >= 18 && age < 30) {
      "中年"
    } else {
      "老年"
    }

    println(res)
  }
}

（3）需求 3：Scala 中返回值类型不一致，取它们共同的祖先类型。

scala

package com.neuedu.chapter04

import scala.io.StdIn

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

    println("input age")
    var age = StdIn.readInt()

    val res: Any = if (age < 18) {
      "童年"
    } else if (age >= 18 && age < 30) {
      "中年"
    } else {
      100
    }

    println(res)
  }
}

（4）需求 4：Java 中的三元运算符可以用 if else 实现

如果大括号{}内的逻辑代码只有一行，大括号可以省略。如果省略大括号，if 只对最近的一行逻辑代码起作用。

scala

package com.neuedu.chapter04

import scala.io.StdIn

object TestIfElse {

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

    // Java
    // int result = flag?1:0

    // Scala println("input age")
    var age = StdIn.readInt()
    val res: Any = if (age < 18) "童年" else "成年"
    "不起作用"
    println(res)
  }
}

4.2 嵌套分支

1）基本语法

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

scala

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

2）案例实操

需求：如果输入的年龄小于 18，返回“童年”。如果输入的年龄大于等于 18，需要再判断：如果年龄大于等于 18 且小于 30，返回“中年”；如果其他，返回“老年”。

scala

package com.neuedu.chapter04

import scala.io.StdIn

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

    println("input age")
    var age = StdIn.readInt()

    val res: String = if (age < 18) {
      "童年"
    } else {
      if (age >= 18 && age < 30) {
        "中年"
      } else {
        "老年"
      }
    }

    println(res)
  }
}

4.3 Switch 分支结构

在 Scala 中没有 Switch，而是使用模式匹配来处理。

模式匹配涉及到的知识点较为综合，因此我们放在后面讲解。

4.4 For 循环控制

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

4.4.1 范围数据循环（To）

1）基本语法

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

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

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

2）案例实操

需求：输出 10 句 "hello world"

scala

package com.neuedu.chapter04

object TestFor {

  def main(args: Array[String]): Unit = {
    for (i <- 1 to 10) {
      println(i + ".hello  wrold" + i)
    }
  }

}

4.4.2 范围数据循环（Until）

1）基本语法

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

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

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

2）案例实操

需求：输出 9 句 "Hello Scala "

object TestFor {def main(args: Array[String]): Unit = { for(i <- 1 until 5 + 1){println("Hello Scala" + i)}}}

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 到 5 中，不等于 3 的值

java

package com.neuedu.chapter04

object TestFor {

  def main(args: Array[String]): Unit = {
    for (i <- 1 to 5 if i != 3) {
      println(i + "Hellowrold")
    }
  }

}

4.4.4 循环步长

1）基本语法

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

说明：by 表示步长

2）案例实操

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

scala

package com.neuedu.chapter04

object TestFor {

  def main(args: Array[String]): Unit = {
    for (i <- 1 to 10  by 2) {
      println(i + "Hellowrold")
    }
  }

}

输出结果

i=1 i=3 i=5 i=7i=9

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 iprintln(res)

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

2）案例实操

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

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

输出结果：

Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

4.4.8 倒序打印

1）说明：如果想倒序打印一组数据，可以用 reverse。

2）案例实操：

需求：倒序打印 10 到 1

java

for (i <- 1 to 10 reverse) {
	println(i)
}

4.5 While 和 do..While 循环控制

While 和 do..While 的使用和 Java 语言中用法相同。

4.5.1 While 循环控制

1）基本语法

循环变量初始化

while (循环条件) {

	循环体(语句) 循环变量迭代

}

说明：

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

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

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

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

2）案例实操

需求：输出 10 句 "你好 Scala "

scala

object TestWhile {
  def main(args: Array[String]): Unit = {
    var i = 0
    while (i < 10) {
      println("你好 Scala " + i)
      i +=  1
    }
  }
}

4.5.2 do..while 循环控制

1）基本语法

循环变量初始化; do{

循环体(语句) 循环变量迭代

} while(循环条件)

说明

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

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

2）案例实操

需求：输出 10 句 "你好 Scala "

scala

object TestWhile {
  def main(args: Array[String]): Unit = {
    var i = 0 
    do {
      println("你好 Scala " + i)
      i +=1
    }
    while (i < 10)
  }
}

4.6 循环中断

1）基本说明

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

2）案例实操

需求 1：采用异常的方式退出循环

scala

for (i <- 1 until 10) {

    if (i == 5) {
        throw new RuntimeException
    }
    println(s"i is ${i}")
}

需求 2：采用 Scala 自带的函数，退出循环

package com.neuedu.scala

import scala.util.control.Breaks

/**
 * @auth 金山老师
 *       title:   书籍代码
 *       creatime: 2022-10-23 17:08
 *       描述 : ${dc}
 */
object Test02_Break {


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

    Breaks.breakable(

      for (i <- 1 until 10) {

        if (i == 5) {
          Breaks.break()
        }
        println(s"i is ${i}")
      }

    )


  }


}

需求 3：对break 进行省略

scala

package com.neuedu.scala

import scala.util.control.Breaks._

/**
 * @auth 金山老师
 *       title:   书籍代码
 *       creatime: 2022-10-23 17:08
 *       描述 : ${dc}
 */
object Test02_Break {


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

    breakable(

      for (i <- 1 until 10) {

        if (i == 5) {
          break()
        }
        println(s"i is ${i}")
      }

    )

  }
}

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

package com.neuedu.scala

object TestBreak {

  def main(args: Array[String]): Unit = {
    for (elem <- 1 to 10) {
      if (elem % 2 == 1) {
        println(elem)
      } else {
        println("continue")
      }
    }
  }

}

4.7 多重循环

1）基本说明

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

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

2）案例实操

需求：打印出九九乘法表

package com.neuedu.scala


/**
 * @auth 金山老师
 *       title:   书籍代码
 *       creatime: 2022-10-23 15:10
 *       描述 : 测试
 */
object TestWhile {
  def main(args: Array[String]): Unit = {

    for (i <- 1 to 9) {
      for (j <- 1 to i) {
        print(j + "*" + i + "=" + (i * j) + "\t")
      }
      println()
    }


  }

}

输出结果：

第 4 章 流程控制 ​

4.1 分支控制if-else ​

4.1.1 单分支 ​

4.1.2 双分支 ​

4.1.3 多分支 ​

4.2 嵌套分支 ​

4.3 Switch 分支结构 ​

4.4 For 循环控制 ​

4.4.1 范围数据循环（To） ​

4.4.2 范围数据循环（Until） ​

4.4.3 循环守卫 ​

4.4.4 循环步长 ​

4.4.5 嵌套循环 ​

4.4.6 引入变量 ​

说明： ​

4.4.7 循环返回值 ​

4.4.8 倒序打印 ​

4.5 While 和 do..While 循环控制 ​

4.5.1 While 循环控制 ​

4.5.2 do..while 循环控制 ​

4.6 循环中断 ​

4.7 多重循环 ​

第 4 章流程控制

4.1 分支控制if-else

4.1.1 单分支

4.1.2 双分支

4.1.3 多分支

4.2 嵌套分支

4.3 Switch 分支结构

4.4 For 循环控制

4.4.1 范围数据循环（To）

4.4.2 范围数据循环（Until）

4.4.3 循环守卫

4.4.4 循环步长

4.4.5 嵌套循环

4.4.6 引入变量

说明：

4.4.7 循环返回值

4.4.8 倒序打印

4.5 While 和 do..While 循环控制

4.5.1 While 循环控制

4.5.2 do..while 循环控制

4.6 循环中断

4.7 多重循环