Scala（第四章 流程控制）

4.1 分支控制 if - else

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

4.1.1 单分支

1）基本语法

if（条件表达式）{
   执行代码块
}

   
   

   
   
1
2
3

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

2）案例实操

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

println(“input age:”)
var age = StdIn.readShort()
if (age < 18){
println(“童年”)
}
}
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

4.1.2 双分支

1）基本语法

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

 
 

 
 
1
2
3
4
5

2）案例实操

//需求：输入年龄，如果年龄小于18岁，则输出”童年“。否则，输出”成年“。
object TestIfElse {
 def main(args: Array[String]): Unit = {
 println("input age:")
 var age = StdIn.readShort()
 if (age < 18){
 println("童年")
 }else{
 println("成年")
 }
 }
}

 
 

 
 
1
2
3
4
5
6
7
8
9
10
11
12

4.1.3 多分支

1）基本语法

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

 
 

 
 
1
2
3
4
5
6
7
8
9

2）案例实操
2.1 需求 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("老年")
 }
 }
}

 
 

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13

2.2 需求 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)
 }
}

 
 

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.3 需求 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)
	 }
 }

 
 

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.4 需求 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)
 }
}

 
 

 
 
1
2
3
4
5
6
7
8
9
10
11
12

4.2 嵌套分支

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

1）基本语法

if(){
   if(){

}else{

}
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7

2）案例实操

需求：如果输入的年龄小于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)
 }
}

 
 

 
 

  
  
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

4.3 Switch分支结构

1、在Scala中没有Switch，而是使用模式匹配来处理
2、模式匹配涉及到的知识点较为综合，因此我们放在后面讲解。

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循环，前后闭合

• 1
• 2
• 3
• 4
• 5
• 6
• 7

2）案例实操

//需求：输出5句“宋宋，告别海狗人参丸吧“
object TestFor {
 def main(args: Array[String]): Unit = {
 for(i <- 1 to 5){
 println("宋宋，告别海狗人参丸吧"+i)
 }
 }
}

 
 

 
 
1
2
3
4
5
6
7
8

4.4.2 范围数据循环（Until）

1）基本语法

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

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

• 1
• 2
• 3
• 4
• 5
• 6
• 7

2）案例实操

//需求：输出5句”宋宋，告别海狗人参丸吧“
object TestFor {
 def main(args: Array[String]): Unit = {
 for(i <- 1 until 5 + 1){
 println("宋宋，告别海狗人参丸吧" + i)
 }
 }
}

 
 

 
 
1
2
3
4
5
6
7
8

4.4.3 循环守卫

1）基本语法

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

 
 

 
 
1
2
3
4

说明：
（1）循环守卫，即循环保护式（也称条件判断式，守卫）。保护式为true则进入循环体内部，为false则跳过，类似于continue。
（2）上面的代码等价

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

 
 

 
 
1
2
3
4
5

2）案例实操

//需求：输出1到5中，不等于3的值
object TestFor {
 def main(args: Array[String]): Unit = {
	 for (i <- 1 to 5 if i != 3) {
	 println(i + "宋宋")
	 }
 }
}

 
 

 
 
1
2
3
4
5
6
7
8

4.4.4 循环步长

1）基本语法

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

 
 

 
 
1
2
3

说明：by表示步长

2）案例实操

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

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

 
 

 
 
1
2
3

输出结果

4.4.5 嵌套循环

1）基本语法

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

 
 

 
 
1
2
3

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

2）基本语法
上面的代码等价

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

 
 

 
 
1
2
3
4
5

4.4.6 引入变量

1）基本语法

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

 
 

 
 
1
2
3

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

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

 
 

 
 
1
2
3
4
5
6

2）案例实操
上面的代码等价于

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

 
 

 
 
1
2
3
4

4.4.7 循环返回值

1）基本语法

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

 
 

 
 
1
2

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

2）案例实操

//需求：将原数据中所有值乘以2，并把数据返回到一个新的集合中。
object TestFor {
 def main(args: Array[String]): Unit = {
 var res = for(i <-1 to 10) yield {
  i * 2
 }
 println(res)
 }
}

 
 

 
 
1
2
3
4
5
6
7
8
9

输出结果：
Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

4.4.8 倒序打印

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

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

 
 

 
 
1
2
3
4

4.5 While 和 do…While 循环控制

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

4.5.1 While循环控制

1）基本语法

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

 
 

 
 
1
2
3
4
5

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

2）案例实操

//需求：输出10句“宋宋”
object TestWhile {

def main(args: Array[String]): Unit = {
var i = 0
while (i < 10) {
println(“宋宋” + i)
i += 1
}
}
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

4.5.2 do…while 循环控制

1）基本语法

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

 
 

 
 
1
2
3
4
5

说明
（1）循环条件是返回一个布尔值的表达式
（2）do…while 循环是先执行，再判断

2）案例实操

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

 
 

 
 
1
2
3
4
5
6
7
8
9
10

4.6 循环中断

1）基本说明

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

2）案例实操

需求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("正常结束循环")
}

 
 

 
 
1
2
3
4
5
6
7
8
9
10
11

需求 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("正常结束循环")
}

 
 

 
 
1
2
3
4
5
6
7
8
9
10

需求 3：对 break 进行省略

import scala.util.control.Breaks._
object TestBreak {
 def main(args: Array[String]): Unit = {
 breakable <span class="token punctuation">{<!-- --></span>
	 <span class="token keyword">for</span> <span class="token punctuation">(</span>elem <span class="token keyword">&lt;-</span> <span class="token number">1</span> to <span class="token number">10</span><span class="token punctuation">)</span> <span class="token punctuation">{<!-- --></span>
	 println<span class="token punctuation">(</span>elem<span class="token punctuation">)</span>
	 <span class="token keyword">if</span> <span class="token punctuation">(</span>elem <span class="token operator">==</span> <span class="token number">5</span><span class="token punctuation">)</span> break
	 <span class="token punctuation">}</span>
 <span class="token punctuation">}</span>

 println<span class="token punctuation">(</span><span class="token string">"正常结束循环"</span><span class="token punctuation">)</span>

}
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

需求 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")
		 }
	 }
 }
}

 
 

 
 
1
2
3
4
5
6
7
8
9
10
11

4.7 多重循环

1）基本说明

（1）将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for，while，do…while均可以作为外层循环和内层循环。【建议一般使用两层，最多不要超过 3 层】
（2）设外层循环次数为 m 次，内层为 n 次，则内层循环体实际上需要执行 m*n 次。

2）案例实操

需求：打印九九乘法表

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

 
 

 
 
1
2
3
4
5
6
7
8
9
10

输出结果：

下一章（第五章） 函数式编程