Scala-流程控制：if-else、for等

我会带着你远行 2022-08-30 14:58 181阅读 0赞

# 流程控制 #

## 分支控制 if-else ##

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

### 单分支 ###

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

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

### 双分支 ###

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

### 多分支 ###

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

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

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

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{ 
                100
            }
            
            println(res)
        }
    }

Java 中的三元运算符可以用 if else 实现，scala没有三元运算符

如果大括号\{\}内的逻辑代码只有一行,大括号可以省略。如果省略大括号,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 (条件表达式) { 
    	执行代码块 1
        if (条件表达式 3) { 
    		执行代码块 3
        }
    } else { 
        执行代码块 2
    }

## Switch分支 ##

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

## For循环控制 ##

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

### 范围数据循环(to) ###

"<-"符号大概的意思可以认为是从后面的表达式取值，然后分别赋值给前面的变量

for(i <- 1 to 3){ 
    	print(i + " ")
    }
    println()
    
    // 本质是
    for(i <- 1.to(3){ 
    	print(i + " ")
    }

1、i 表示循环的变量,<- 规定 to

2、i 将会从 1-3 循环,**前后闭合** **\[1, 3\]**

3、to的本质是方法的调用

### 范围数据循环(until) ###

for(i <- 1 until 3) { 
    	print(i + " ")
    }
    println()
    
    // to和until的底层都是Range对象，而调用to的话，会将include的相关字段变为true（默认是false）
    // until则是直接使用include为false
    // 以上的until也等同于
    for(i <- Range(1, 3)) { 
    	print(i + " ")
    }

1、这种方式和前面的区别在于 i 是从 1 到 3-1

2、即**前闭合后开**的范围 **\[1, 3)**

3、until的本质是方法的调用

### 循环守卫 ###

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

1、循环守卫,即循环保护式(也称条件判断式,守卫)。保护式为 true 则进入循环体内部,为 false 则跳过,类似于 continue。  
2、上面的代码等价

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

### 循环步长 ###

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

说明:by 表示步长

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

### 嵌套循环 ###

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 3; j = 4 - i) { 
    	println("i=" + i + " j=" + j)
    }

说明:

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

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

### 循环返回值 ###

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

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

默认for循环的返回值是Unit

### 倒序打印 ###

如果想倒序打印一组数据,可以用 reverse。

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

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

While 和 do…While 的使用和 Java 语言中用法相同。不建议使用while和do…while

### While 循环控制 ###

while (循环条件) { 
    	循环体
    }

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

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

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

4、因为 while 中没有返回值,所以当要用该语句来计算并返回结果时,就不可避免的使用变量,而变量需要声明在 while 循环的外部,那么就等同于循环的内部对外部的变量造成了影响,所以不推荐使用,而是**推荐使用 for 循环**。

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

do { 
        循环体
    } while (循环判断语句)

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

## 循环中断 ##

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

采用异常的方式退出循环

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

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

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

循环遍历 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、将一个循环放在另一个循环体内,就形成了嵌套循环。其中, for, while, do…while均可以作为外层循环和内层循环。【建议一般使用两层,最多不要超过 3 层】

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