本文共 4315 字，大约阅读时间需要 14 分钟。

一、分支if-else

1.1 单分支

if  (条件表达式)  {
   	执行代码块}def main(args: Array[String]): Unit = {
                   println("input age:")        var age = StdIn.readShort()        if (age < 18){
               println("童年")        }    }

1.2 双分支

if (条件表达式) {
   	执行代码块1} else {
   执行代码块2}def main(args: Array[String]): Unit = {
           println("input age:")        var age = StdIn.readShort()        if (age < 18){
               println("童年")        }else{
               println("成年")        }    }

1.3 多分支

if (条件表达式1) {
   	执行代码块1}else if (条件表达式2) {
   	执行代码块2}   ……else {
   	执行代码块n}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("老年")        }    }

1.4 嵌套分支

if(){
       if(){
       }else{
       }	}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)    }

二、For循环

2.1 To

前后闭合,底层为Range

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

等同于

for(i <- Range(1,4)){
       print(i + " ")}

2.2 Until

前闭合后开，底层为Range

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

等同于

for(i <- Range(1,3)) {
       print(i + " ")}

2.3 循环守卫

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

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

等同于

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

2.4 循环步长

by表示步长

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

等同于

for (i <- Range(1,10,2)) {
       println("i=" + i)}

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

2.6 引入变量

for推导式一行中有多个表达式时，所以要加 ; 来隔断逻辑

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

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

2.7 循环返回值

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

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

三、While循环

3.1 while

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

while (循环条件) {
         循环体(语句)      循环变量迭代}def main(args: Array[String]): Unit = {
           var i = 0        while (i < 10) {
               println("天天向上" + i)            i += 1        }}

3.2 do…while

循环变量初始化;   do{
          循环体(语句)       循环变量迭代   } while(循环条件)    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在给你封装了这种异常 -> Breaks

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

2. 引入了Java中对静态包的直接导入 -> import static java.until.Math（导入Math中的静态包，且在使用时不用编写Math.abs() ，直接用abs）
3. 在Scala中为import scala.util.control.Breaks._，直接使用方法，不需要用点的方式

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

五、多重循环

打印九九乘法表

def main(args: Array[String]): Unit = {
           for (i <- 1 to 9) {
               for (j <- 1 to i) {
                   print(j + "*" + i + "=" + (i * j) + "\t")            }            println()        }    }

转载地址：http://ptzhn.baihongyu.com/