Scala (四) --------- 流程控制

偏执的太偏执、 2024-04-08 13:33 105阅读 0赞

#### 目录 ####

*  一、分支控制 if-else
 *   *  1. 单分支
     *  2. 双分支
     *  3. 多分支
 *  二、嵌套分支
 *  三、Switch 分支结构
 *  四、For 循环控制
 *   *  1. 范围数据循环 (To)
     *  2. 范围数据循环 (Until)
     *  3. 循环守卫
     *  4. 循环步长
     *  5. 嵌套循环
     *  6. 引入变量
     *  7. 循环返回值
     *  8. 倒序打印
 *  五、While 和 do..While 循环控制
 *   *  1. While 循环控制
     *  2. do..while 循环控制
 *  六、循环中断
 *  七、多重循环

--------------------

## 一、分支控制 if-else ##

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

### 1. 单分支 ###

**基本语法**

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

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

**案例实操**

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

object TestIfElse {
        
      def main(args: Array[String]): Unit = {
        
    	 println("input age:")
    	 var age = StdIn.readShort()
    	 if (age < 18){
        
    		 println("童年")
    	 }
      }
    }

### 2. 双分支 ###

**基本语法**

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

**案例实操**

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

object TestIfElse {
        
      def main(args: Array[String]): Unit = {
        
     	println("input age:")
    	 var age = StdIn.readShort()
    	 if (age < 18){
        
    		println("童年")
    	 }else{
        
    	 	println("成年")
     	 }
      }
    }

### 3. 多分支 ###

**基本语法**

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

**案例实操**

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

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：Scala 中 if else 表达式其实是有返回值的，具体返回值取决于满足条件的代码体的最后一行内容。

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：Scala 中返回值类型不一致，取它们共同的祖先类型。

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：Java 中的三元运算符可以用 if else 实现

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

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

## 二、嵌套分支 ##

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

**基本语法**

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

**案例实操**

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

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

## 三、Switch 分支结构 ##

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

## 四、For 循环控制 ##

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

### 1. 范围数据循环 (To) ###

**基本语法**

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

i 表示循环的变量，`<-` 规定 to  
i 将会从 1-3 循环，前后闭合

**案例实操**

需求：输出 5 句 fancy

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

### 2. 范围数据循环 (Until) ###

**基本语法**

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

这种方式和前面的区别在于 i 是从 1 到 3-1  
即使前闭合后开的范围

**案例实操**

需求：输出 5 句 fancy

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

### 3. 循环守卫 ###

**基本语法**

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

说明：  
循环守卫，即循环保护式 (也称条件判断式，守卫)。  
保护式为 true 则进入循环体内部，为 false 则跳过，类似于 continue。

**上面的代码等价**

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

**案例实操**

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

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

### 4. 循环步长 ###

**基本语法**

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

说明：by 表示步长

**案例实操**

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

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

输出结果

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

### 5. 嵌套循环 ###

**基本语法**

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

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

上面的代码等价

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

### 6. 引入变量 ###

**基本语法**

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

说明：

for 推导式一行中有多个表达式时，所以要加 ; 来隔断逻辑  
for 推导式有一个不成文的约定：当 for 推导式仅包含单一表达式时使用圆括号，当包含多个表达式时，一般每行一个表达式，并用花括号代替圆括号，如下

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

**案例实操**

上面的代码等价于

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

### 7. 循环返回值 ###

**基本语法**

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

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

**案例实操**  
需求：将原数据中所有值乘以 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)

### 8. 倒序打印 ###

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

**案例实操：**

需求：倒序打印 10 到 1

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

## 五、While 和 do…While 循环控制 ##

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

### 1. While 循环控制 ###

**基本语法**

循环变量初始化

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

说明：

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

**案例实操**  
需求：输出 10 句 “宋宋，喜欢海狗人参丸”

object TestWhile {
        
     def main(args: Array[String]): Unit = {
        
    	 var i = 0
    	 while (i < 10) {
        
    	 println("宋宋，喜欢海狗人参丸" + i)
    	 	i += 1
    	 }
     }
    }

### 2. do…while 循环控制 ###

**基本语法**

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

说明

*  循环条件是返回一个布尔值的表达式
 *  do…while 循环是先执行，再判断

**案例实操**  
需求：输出 10 句 “宋宋，喜欢海狗人参丸”

object TestWhile {
        
     def main(args: Array[String]): Unit = {
        
    	 var i = 0
    	 do {
        
    	 	println("宋宋，喜欢海狗人参丸" + i)
    		 i += 1
    	 } while (i < 10)
     }
    }

## 六、循环中断 ##

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

**案例实操**

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

def main(args: Array[String]): Unit = {
        
     try {
        
    	 for (elem <- 1 to 10) {
        
    	 println(elem)
    	 if (elem == 5) throw new RuntimeException
     }catch {
        
     	case e =>
     }
     println("正常结束循环")
    }

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

import scala.util.control.Breaks
    def main(args: Array[String]): Unit = {
        
     Breaks.breakable(
    	 for (elem <- 1 to 10) {
        
    		 println(elem)
    	 	if (elem == 5) Breaks.break()
    	 }
     )
     println("正常结束循环")
    }

需求 3：对 break 进行省略

import scala.util.control.Breaks._
    object TestBreak {
        
     def main(args: Array[String]): Unit = {
        
    	 breakable {
        
    		 for (elem <- 1 to 10) {
        
    		 	println(elem)
    			if (elem == 5) break
    		 }
    	 }
    	 println("正常结束循环")
     }
    }

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

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

## 七、多重循环 ##

**基本说明**

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

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

**案例实操**

需求：打印出九九乘法表

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