Scala流程控制

一.if-else

if-else分支控制有三种：单分支、双分支、多分支。废话不多说，直接上代码。

1.单分支
if  (条件表达式)  {
	执行代码块
}

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

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

if else 表达式的返回值

scala 与java if 分支的区别：

• 在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
        }
		//例：如果age < 18 res = “童年”
        println(res)
    }
}

if else 实现三元运算

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

二.for循环

1.基础语法：<-、to、until

for(变量名:数据类型 <- 数组|集合){

}
# 数据类型可以省略，因为可以通过集合中的元素推断出来

for(i <- 1 to 3){ // 1.to(3) 
    print(i + " ")
}
println()
//前闭后
for(i <- 1 until 3) {
    print(i + " ")
}

• 1）i 表示循环的变量，<- 规定to
• 2）to：表示 i 将会从 1-3 循环，前后闭合
• 3）until：则表示前闭合后开的范围

i <- 方法：

• 其会调用Range的foreach方法
  

1 to 3：

• 等价于：1.to(3)
• Int类并没有to方法，其先会将1转换为RichInt()类对象
  
• 然后RichInt对象调用相关的to方法
  

2.循环守卫：if

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

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

3.循环步长：by

for (i <- 1 to 10 by 2) {
    println("i=" + i)
}
//def to(end:Double)需要指定步长，否则报错
for (i <- 1.0 to 10.0 by 0.2) { 
     println("i=" + i)
}
//def to(end:Int)默认步长为1，此时需指定
for (i <- 10 to 1 by -1) { 
     println("i=" + i)
}

• RichInt的to方法默认步长为1；
• def to(end:Double)需要指定步长，否则报错

4.嵌套循环

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

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

5.引入变量

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

说明：

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

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

6.循环返回值：yield

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

输出结果：
Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

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

7.倒序打印：reverse

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

三.While和do…While

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

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

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

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

说明：

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

四.循环中断

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

Scala中通过抛出异常，并对异常进行处理，来实现break和continue的功能。

• Scala提供Breaks类的 breakable() 与 break() 来实现。

---

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

2.采用Scala自带的函数：Breaks的breakable()与break()

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）底层源码

Breaks.breakable()也是采用的try…catch异常处理实现循环中断。其中在自定义函数体op中设置break()中断条件。

2）对Breaks进行省略—静态导入

导入某一个类下的所有"静态成员"：

• import scala.util.control.Breaks._

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

3）扩展：java静态导入

java静态导入：即导入当前这个类中的对于静态成员

静态导入的注意事项：

• A:方法必须是静态的
• B:如果有多个同名的静态方法，容易不知道使用谁?这个时候要使用，必须加前缀。由此可见，意义不大，所以一般不用，但是要能看懂

// java.lang下的包不需要导入，但使用具体的静态成员时需要指定具体类名
public class Test {
    public static void main(String[] args) {
        System.out.println(Math.PI);
        System.out.println(Math.abs(-5));
    }
}

//可以使用java静态导入省略类名指定
import static java.lang.Math.*；
public class Test {
    public static void main(String[] args) {
        // System.out.println(Math.PI);
        // System.out.println(Math.abs(-5));
        System.out.println(PI);  //直接使用，不需要指定类名Math.PI
        System.out.println(abs(-5));
    }
}