杰霸霸博客

主题

流程控制 ​

1. 分支控制if-else ​

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

1.1 单分支 ​

基本语法:

scala
//当条件表达式为ture时，就会执行{ }的代码
if (条件表达式) {
    执行代码块
}

1.2 双分支 ​

基本语法:

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

1.3 多分支 ​

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

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

scala
def main(args: Array[String]): Unit = {
    println("请输入你的年龄： ")
    val age = StdIn.readInt()
    val res:String = if(age<18){
        "未成年"
    }else if(age>=18 && age<60){
        "中青年"
    }else{
        "老年"
    }
    println(s"结果是： ${res}")
}

运行结果：
Alt text 判断返回值类型可以借助IDEA提示:
Alt text 如图，null的父类是java类型(all java classes)，string的父类也是java类型的String类型, 所以汇总为String类型

1.4 嵌套分支 ​

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

scala
if(){
    if(){
        ......
    }else{
        ......
    }
}

2. Switch分支结构 ​

在 Scala中没有Switch，而是使用模式匹配来处理。请参考章节模式匹配

3. For 循环控制 ​

Scala也为for循环这一常见的控制结构提供了非常多的特性，这些for循环的特性被称为for推导式或for表达式。类似Java中的高级for循环，区别在于for循环中的:变成了<-箭头, Scala的循环里:用来声明类型。

3.1 范围数据循环(to) ​

前后闭合范围。
基本语法：

scala
// i表示循环的变量，<- 规定to, i将会从1-3循环，前后闭合
for (i <- 1 to 3) {
    print(i + " ")
}
println()

3.2 范围数据循环(Until) ​

前闭合后开的范围。
基本语法:

scala
// 这种方式和前面的区别在于i是从 1到2
for (i <- 1 until 3) {
    print(i + " ")
}
println()

使用Range(1,3)和1 util 3效果一样, 如果集合中类型确定，也就是元素类型单一，可以不写:

scala
for (num <- 1 until 5 ) {
    print(num+ "")
}
println()
// 等效执行
for (num <- Range(1, 5)){
    print(num+ "")
}
println()

运行结果：
Alt text

3.3 循环守卫 ​

循环守卫，即循环保护式(也称条件判断式守卫)。保护式为true则进入循环体内部，为false则跳过，类似于continue。 基本语法：

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

上面的代码等价为：

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

3.4 循环步长 ​

使用关键字by表示步长。
基本语法:

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

输出1到10以内的所有奇数:

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

3.5 嵌套循环 ​

没有关键字间隔开，所以范围后一定要加;来隔断逻辑。 基本语法：

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

上面的代码等价：

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

3.6 引入变量 ​

基本语法:

scala
for(i <- 1 to 3; j = 4 - i) {
    println("i=" + i + " j=" + j)
}
  1. for推导式一行中有多个表达式时，所以要加;来隔断逻辑。
  2. for推导式有一个不成文的约定：当for推导式仅包含单一表达式时使用圆括号，当包含多个表达式时，一般每行一个表达式，并用花括号代替圆括号
scala
for {
    i <- 1 to 3
    j = 4 - i
} {
    println("i=" + i + " j=" + j)
}

3.7 循环返回值 ​

默认for循环返回最后一次遍历的结果，如果需要所有遍历结果，需要使用yield关键字，它将遍历过程中处理的结果返回到一个新Vector集合中。
基本语法:

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

3.8 倒序遍历 ​

如果想倒序打印一组数据，可以用reverse关键字。

scala
for(i <- 1 to 10 reverse){
    println(i)
}

4. While和do..While循环控制 ​

while和do..while的使用和Java语言中用法相同。

4.1 While 循环控制 ​

基本语法

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

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

4.2 do..while 循环控制 ​

基本语法：

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

1️⃣ 循环条件是返回一个布尔值的表达式
2️⃣ do..while 循环是先执行，再判断

4.3 循环中断 ​

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

  1. 采用异常的方式退出循环
scala
def main(args: Array[String]): Unit = {
    try {
        for (elem <- 1 to 10) {
            println(elem)
            if (elem == 3) throw new RuntimeException
        }
    }
    println("正常结束循环")
}
  1. 采用Scala自带的函数break()，退出循环，底层会抛出异常跳出循环，但它会导致跳出方法直接返回，循环外后面还有代码需要执行，因此需要配合Breaks.breakable{}来捕获异常使用。
scala
import scala.util.control.Breaks

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

上面的代码可以对break进行简写，使得和java方式一样简洁。需要提前静态导入Breaks。

scala
import scala.util.control.Breaks._

object ForDemo {
    def main(args: Array[String]): Unit = {

        breakable {
            for (elem <- 1 to 10) {
                println(elem)
                if (elem == 5) break
            }
        }
        println("正常结束循环")
    }
}

循环遍历10以内的所有数据，奇数打印，偶数跳过(continue)

scala
def main(args: Array[String]): Unit = {
    for (elem <- 1 to 10) {
        if (elem % 2 == 1) {
            println(elem)
        } else {
            println("continue")
        }
    }
 }

4.4 多重循环 ​

基本说明

  1. 将一个循环放在另一个循环体内，就形成了嵌套循环。其中for，while，do…while均可以作为外层循环和内层循环。【建议一般使用两层，最多不要超过 3 层】
  2. 设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。 打印出九九乘法表
scala
def main(args: Array[String]): Unit = {
    for (i <- 1 to 9) {
        for (j <- 1 to i) {
            print(j + "*" + i + "=" + (i * j) + "\t")
        }
        println()
    }
}

运行结果：
Alt text