Scala 的流程控制语句-CSDN博客

本文链接：https://blog.csdn.net/weixin_44480009/article/details/139155301

一、分支控制

1. if 分支

object TestIf {
    /*
      if (condition) { statement }
     */
    def main(args:Array[String]): Unit = {
        println("请输入您的成绩")
        val score: Int = StdIn.readInt()
        
        if (score >= 60) {
            println("及格")
        }
    }
}

2. if-else 分支

object TestIfElse {
    /*
          if (condition) { 
            statement1 
          } else { 
            statement2 
          }
     */
    def main(args:Array[String]): Unit = {
        println("请输入您的成绩")
        val score: Int = StdIn.readInt()
        
        if (score >= 60) {
            println("及格")
        } else {
            println("不及格")
        }
    }
}

3. if-else if-else 分支

object TestIfElseIf {
    /*
          if (condition) { 
            statement1 
          } else if { 
            statement2 
          } ...
          else {
          	statement3
          }
     */
    def main(args:Array[String]): Unit = {
        println("请输入您的成绩")
        val score: Int = StdIn.readInt()
        
        if (score >= 60) {
            println("及格")
        } else if (score >= 80) {
            println("良好")
        } else if (score >= 90) {
            println("优秀")
        } else {
            println("不及格")
        }
    }
}

4. if/if-else/if-elseif 分支返回值

// 分支返回值可以实现类似 Java 的三元运算符 a?b:c
object TestIfResult {
    def main(args:Array[String]): Unit = {
        println("请输入您的成绩")
        val score: Int = StdIn.readInt()
        
        val result: Unit = if (score >= 60) {
            println("及格")
        } else if (score >= 80) {
            println("良好")
        } else if (score >= 90) {
            println("优秀")
        } else {
            println("不及格")
        }
        println("result:" + result)
        
        val result2: String = if (score >= 60) {
            println("及格")
            "及格"
        } else if (score >= 80) {
            println("良好")
            "良好"
        } else if (score >= 90) {
            println("优秀")
            "优秀"
        } else {
            println("不及格")
            "不及格"
        }
        println("result2:" + result2)
        
        val result22: Unit = if (score >= 60) {
            println("及格")
            "及格"
        } else if (score >= 80) {
            println("良好")
            "良好"
        } else if (score >= 90) {
            println("优秀")
            "优秀"
        } else {
            println("不及格")
            "不及格"
        }
        println("result22:" + result22)
        
        val result3: Any = if (score >= 60) {
            println("及格")
            "及格"
        } else if (score >= 80) {
            println("良好")
            "良好"
        } else if (score >= 90) {
            println("优秀")
            score
        } else {
            println("不及格")
            score
        }
        println("result3:" + result3)
        
    }
}

二、循环控制

1. for循环

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

1.1 范围数据循环

object TestForTo {
    def main(args: Array[String]): Unit = {
        // java for循环: for(int i=0; i < 10; i++) {...}
        for(i <- 1 to 10) { // 包含边界
            println(i + ".helloWorld")
        }
        
        // 等价于
        for(i <- 1.to(10)) { // to 方法返回一个 Range.Inclusive 对象，元素为 1~10
            println(i + ".helloWorld")
        }
    }
}

until

object TestForTo {
    def main(args: Array[String]): Unit = {
        for(i <- 1 until 10) { // 不包含边界
            println(i + ".helloWorld")
        }
        
        // 等价于
        for(i <- Range(1, 10)) { 
            println(i + ".helloWorld")
        }
    }
}

1.2 循环守卫

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

object TestFor {
    /*
        java continue语法
        for(int i=0; i < 10; i++) {
        	if(i==5) {
        		continue;
        	} else {
        		...
        	}
        }
     */
    def main(args: Array[String]): Unit = {
        // 循环守卫
        for(i <- 1 to 10 if i != 5) {
            println(i)
        }
        
        // 等价于
        for(i <- 1 to 10) {
            if(i != 5) {
                println(i)
            }
        }
        
    }
}

1.3 循环步长

object TestFor {
    def main(args: Array[String]): Unit = {
        // 循环步长，step 不能为 0 
        for(i <- 1 to 10 by 2) {
            println(i) // 1 3 5 7 9
        }
        
        // 等价于
        for(i <- (1 to 10).by(2)) { // Range.by() 方法
            println(i) // 1 3 5 7 9
        }
        
        for(i <- 1.0 to 10.0 by 0.5) {
            println(i)
        }
        
        for(i <- 10 to 1 by -1) {
            println(i)
        }
        
    }
}

1.4 循环嵌套

object TestFor {
    def main(args: Array[String]): Unit = {
        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)
            }
        }
        
        // 九九乘法表
        for(i <- 1 to 9; j <- 1 to i) {
            print(s"$j * $i = ${i * j}\t")
            if(j==i) println()
        }
    }
}

1.5 循环引入变量

object TestFor {
    def main(args: Array[String]): Unit = {
        for(i <- 1 to 10; j = 10 - i) {
            println(s"i = $i, j = $j")
        }
        
        // 等价于
        for {
            i <- 1 to 10
            j = 10 - i
        } {
            println(s"i = $i, j = $j")
        }
        
        // 等价于
        for (i <- 1 to 10) {
            val j = 10 - i
            println(s"i = $i, j = $j")
        }
        
    }
}

1.6 循环返回值

object TestFor {
    def main(args: Array[String]): Unit = {
        // 默认的 for 循环返回值为 Unit
        val res1: Unit = for(i <- 1 to 10) {
            // println(i)
            // "hello"
            // i
        }
        
        // yield 关键字将遍历过程中处理的结果返回到一个新 Vector 集合
        val res2: immutable.IndexedSeq[Int] = for(i <- 1 to 10) yield i
        println(res2) // Vector(1,2,3,4,5,6,7,8,9,10)
        
        
        val res3: immutable.IndexedSeq[Int] = for(i <- 1 to 10) yield {
            i * 2
        }
        println(res3) // Vector(2,4,6,8,10,12,14,16,18,20)
        
    }
}

1.7 循环倒序

object TestFor {
    def main(args: Array[String]): Unit = {
        // 倒序循环
        for(i <- 1 to 10 reverse) {
            println(i) // 10 9 8 7 6 5 4 3 2 1
        }
        
        // 等价于
        for(i <- 10 to 1 by -1) { 
            println(i)
        }
        
    }
}

1.8 案例

需求：打印输出 n 行的等腰三角形
```
   *
  ***
 *****
*******
```

实现：

object TestPractice {
    def main(args: Array[String]): Unit = {
        println("请输入打印的行数")
        val line: Int = StdIn.readInt()
        
        for(i <- 1 to line; j = 2 * i - 1; m = line - i) {
            println(" " * m + "*" * j)
        }
        
    }
}

2. while/do-while 循环

不推荐使用

2.1 while 循环

object TestWhile {
    def main(args: Array[String]): Unit = {
        // 需要在循环外部定义判断变量
        var a: Int = 1
        while(i <= 10) {
            println("while loop:" + a)
            a += 1
        }
        
        // while 语句没有返回值，即整个 while 语句的结果是 Unit 类型
    }
}

2.2 do-while 循环

object TestDoWhile {
    def main(args: Array[String]): Unit = {
        // do-while 至少会执行一次
        var b: Int = 0
        do {
            println("do-while loop:" + b)
            b -= 1
        } while(b > 0)
        
    }
}

3. 循环中断

Scala 去掉了 break 和 continue 关键字

object TestBreak {
    def main(args: Array[String]): Unit = {
        // 使用抛出异常的方式实现 break 功能
        try {
            for(i <- 1 to 10) {
                if(i == 3) {
                    throw new RuntimeException
                }
                println(i)
            }
        } catch {
            case e: Exception =>  // 不作任何处理
        }
        
        println("循环外")
        println("===============================")
        
        // 使用 Breaks 类的 break 方式实现
        // 导包时使用 import scala.util.control.Breaks._ 调用方法时可以省略 Breaks
        Breaks.breakable( // 方法内部是 try-catch
            for(i <- 1 to 10) {
                if(i == 3) {
                    Breaks.break() // 方法内部是 throw 异常
                }
                println(i)
            }
        )
        
        println("循环外")
    }
}