Scala入门（四）流程控制

总目录

1.分支控制if-else

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

1.1 单分支

1）基本语法

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

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

2）案例

// 输入一个数字，如果是偶数则输出even
val number = StdIn.readInt()
if(number % 2 == 0) {
    println("even")
}

1.2 双分支

1）基本语法

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

2）案例

// 输入一个数字，如果是奇数则输出odd，如果是偶数则输出even
val number = StdIn.readInt()
if(number % 2 == 0) {
    println("even")
} else {
    println("odd")
}

1.3 多分支

1）基本语法

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

2）案例

// 输入一个小于100的数字，如果是奇数则输出odd，如果是偶数则输出even，如果大于100则输出超出范围
val number = StdIn.readInt()
if(number > 100) {
    println("超出范围")
} else if(number % 2 == 0) {
    println("even")
} else {
    println("odd")
}

注意：

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

val number = StdIn.readInt()
val res: String = if(number > 100) {
    "超出范围"
} else if(number % 2 == 0) {
    "even"
} else {
    "odd"
}

• Scala 中返回值类型不一致，取它们共同的祖先类型。

val number = StdIn.readInt()
val res: Any = if(number > 100) {
    number
} else if(number % 2 == 0) {
    "even"
} else {
    "odd"
}

• Java 中的三元运算符可以用 if else 实现
  如果大括号{}内的逻辑代码只有一行，大括号可以省略。如果省略大括号，if 只对最近的一行逻辑代码起作用。

val number = StdIn.readInt()
val res: String = if(number % 2 == 0) "even" else "odd"

1.4 嵌套分支

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

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

2）案例

// 输入一个小于100的数字，如果是奇数则输出odd，如果是偶数则输出even，如果大于100则输出超出范围
val number = StdIn.readInt()
val res: String = if(number > 100) {
    "超出范围"
} else {
    if(number % 2 == 0) {
    	"even"
    } else {
        "odd"
    }
}

2. For循环控制

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

2.1 范围数据循环（To）

1）基本语法

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

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

2）案例

// 输出test1-test5
for(i <- 1 to 5) {
    println("test" + i)
}

2.2 范围数据循环（Until）

1）基本语法

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

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

2）案例

// 输出test1-test5
for(i <- 1 until 5 + 1) {
    println("test" + i)
}

2.3 循环守卫

1）基本语法

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

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

（2）以下代码与上一代码等价

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

2）案例

// 输出test0-test5
for(i <- -1 to 5 if i != -1) {
    println("test" + i)
}

2.4 循环步长

1）基本语法

for (i <- 1 to 10 by 2) {
    print(i + " ")	// 1 3 5 7 9 
}

说明：by 表示步长

2）案例

// 输出1到10以内的所有偶数
for (i <- 0 to 10 by 2) {
	println(i + " ")	// 0 2 4 6 8 10 
}

2.5 嵌套循环

1）基本语法

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

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

2）案例

// 此处代码与上一代码等价
for (i <- 1 to 3) {
     for (j <- 1 to 3) {
     	println("i = " + i + " j= " + j)
     }
}

2.6 引入变量

1）基本语法

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

说明：

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

2.7 循环返回值

1）基本语法

val res = for(i <- 1 to 10) yield i
println(res)	// Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

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

2）案例

// 将原数据中所有值乘以 2，并把数据返回到一个新的集合中。
var res = for(i <-1 to 10) yield {
	i * 2
}
println(res)	// Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

2.8 倒序打印

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

// 倒序打印10到1
for(i <- 1 to 10 reverse){
	println(i)
}

3.While和do…While循环控制

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

3.1 While循环控制

1）基本语法

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

说明：

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

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

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

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

2）案例

// 输出test1-test5
var i = 1
while(i < 6) {
    println('test' + i)
    i += 1
}

3.2 do…while循环控制

1）基本语法

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

说明：

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

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

2）案例

// 输出test1-test5
var i = 1
do {
    println('test' + i)
    i += 1
} while(i < 6)

4.循环中断

1）基本说明

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

2）案例

// 采用异常的方式退出循环
try {
    for (elem <- 1 to 10) {
        if (elem == 5) throw new RuntimeException
        println(elem)
    }
} catch {
    case e: Exception =>	// 什么都不做，只是退出循环
}
println("循环体外")

// 采用 Scala 自带的函数，退出循环
import scala.util.control.Breaks

Breaks.breakable(
    for (elem <- 1 to 10) {
        println(elem)
        if (elem == 5) Breaks.break()
    }
)

// 对 break 进行省略
import scala.util.control.Breaks._

breakable {
    for (elem <- 1 to 10) {
        if (elem == 5) break
        println(elem)
    }
}

5.多重循环

1）基本说明

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

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

2）案例

// 打印九九乘法表
for (i <- 1 to 9) {
    for (j <- 1 to i) {
        print(j + "*" + i + "=" + (i * j) + "\t")
    }
    println()
}