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

流程控制

分支控制 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 次。