if条件

除了和 Java 相同的 if... else if ... else语句功能外，Scala中的if代码块可以有返回值，即代码块最后一行会被当做返回值：

  1. val a: Int = 10
  3. // 可以用变量接收if的返回值
  4. val result: Int = 
  5. if (a < 1) {
  6.     a + 1  // 代码块中的最后一句代码就是返回值
  7. } else if (a < 10) {
  8.     a + 10
  9. } else if (a > 100) {
  10.     a
  11. } else {
  12.     100
  13. }
  15. println(result)

for循环

语法：

  1. for( var x <- Range ){
  2.    statement(s);
  3. }

:::info 以上语法中，Range 可以是一个数字区间表示 i to j （包含j），或者 i until j （不包含 j）。左箭头 <- 用于为变量 x 赋值。
注意：i >= j ，例如1 to 10， 不可 i < j :::
i to j 语法(包含 j)

  1. object Test {
  2.    def main(args: Array[String]) {
  3.       var a = 0;
  4.       // for 循环
  5.       for( a <- 1 to 10){
  6.          println( "Value of a: " + a );
  7.       }
  8.    }
  9. }

i until j 语法(不包含 j)

  1. object Test {
  2.    def main(args: Array[String]) {
  3.       var a = 0;
  4.       // for 循环
  5.       for( a <- 1 until 10){
  6.          println( "Value of a: " + a );
  7.       }
  8.    }
  9. }

循环嵌套

Scala支持像 Java 一样的循环嵌套，另外，还可以将嵌套的循环写到一行中：
可以使用分号 (;) 来设置多个区间（嵌套for循环）

  1. object Test {
  2.    def main(args: Array[String]) {
  3.       var a = 0;
  4.       var b = 0;
  5.       // for 循环
  6.         for (a <- 1 to 3; b <- 1 to 3) {
  7.           println("Value of a: " + a + "b:" + b);
  8.         }
  9.    }
  10. }
  12. 输出结果：
  13. Value of a: 1 b: 1
  14. Value of a: 1 b: 2
  15. Value of a: 1 b: 3
  16. Value of a: 2 b: 1
  17. Value of a: 2 b: 2
  18. Value of a: 2 b: 3
  19. Value of a: 3 b: 1
  20. Value of a: 3 b: 2
  21. Value of a: 3 b: 3

集合的嵌套循环：

  1. val list = List(List(1, 2, 3), List(4, 5, 6), List(7, 8, 9))  // List内部元素还是List
  3. // 遍历
  4. for (subList <- list; elem <- subList) {
  5.     println(elem)
  6. }
  8. 输出结果：
  9. 1
  10. 2
  11. 3
  12. 4
  13. 5
  14. 6
  15. 7
  16. 8
  17. 9

设置步长和倒序

to、until方法指定步长： :::info 步长的意思类似 i++，by 2 就是每次 + 2 :::

  1. // 0.to(10)得到一个Range对象，然后调用Range对象的by方法指定步长
  2. // 指定步长为2
  3. for(i <- 0 to 10 by 2) {
  4.     println(i)
  5. }
  7. // 步长还可以定义为负值：当起始值大于结束值时，将步长定义为负值，则可以倒序遍历。
  8. //（如果起始值小于结束值，步长定义为负值，那么Scala认为是死循环，就直接跳过不运行这个循环）
  9. // 但是步长不可以设置为0
  10. for(i <- 10 until 0 by -2) {
  11.     println(i)
  12. }
  14. // 也可以通过调用Range的reverse方法实现反转倒序遍历
  15. for(i <- 0 to 10 by 2 reverse) {
  16.     println(i)
  17. }

集合元素遍历

对于数组、集合的元素，也可以直接进行遍历：

  1. // 遍历数组的元素
  2. for (i <- Array(11, 24, 51, 13, 33)) {
  3.     println(i)
  4. }
  6. // 遍历集合的元素
  7. for (i <- List(11, 24, 51, 13, 33)) {
  8.     println(i)
  9. }

循环守卫

Scala的循环语句中，可以加入条件判断（即循环保护式，循环守卫），当条件判断为true时才执行，为false时则直接continue（Scala中没有continue关键字）。

例如：

  1. // 遍历1到5中的所有偶数
  2. for (i <- 1 to 5 if i%2 == 0) {  // 直接以循环守卫的方式加入判断语句：if i%2 == 0
  3.     println(i)
  4. }

引入变量

示例：

  1. val list = List(10,11,12,13,14,15)
  3. // 在循环表达式中，可以新建一个变量，即使这个变量不是嵌套循环
  4. for (i <- 0 to 5 ; j = list(i)) {
  5.     println(j)
  6. }

循环的返回值

通过yield关键字声明循环要返回的内容：

  1. // 此处的 yield 和线程无关，只是声明要返回的内容
  2. // 返回的是一个Vector集合
  3. val forResult = for (i <- 1 to 10) yield (i * 2) ;
  4. println(forResult)
  6. 输出结果：
  7. Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

循环中断

Scala为了更好的适应函数式变成，去掉了 break、continue，推荐使用函数式的风格解决break和continue的功能，而不是一个关键字。

Scala中使用breakable控制结构来实现break和continue功能。

对于continue，可以使用循环守卫、if判断等方式实现。

对于break，可以通过抛出异常的方式实现退出。

例如：

  1. try {
  2.     for(i <- 0 until 5) {
  3.         if (i == 3) {
  4.             throw new RuntimeException
  5.         }
  6.         println(i)
  7.     }
  8. } catch {
  9.     case e: Exception =>  // 什么都不处理，只是接收异常然后退出循环
  10. }
  12. println("-----------------------")

使用breakable方式退出循环（本质上也是使用抛出异常的方式）：

  1. Breaks.breakable(  // 包装了的try...catch
  2.     for(i <- 0 until 5) {
  3.         if (i == 3) {
  4.             Breaks.break()  // 抛出异常
  5.         }
  6.         println(i)
  7.     }
  8. )
  10. println("---------------")

进一步：

  1. import scala.util.control.Breaks._   // 引入Breaks下的所有方法
  3. // 进一步简写
  4. breakable(
  5.     for(i <- 0 until 5) {
  6.         if (i == 3) {
  7.             break()
  8.         }
  9.         println(i)
  10.     }
  11. )

while和do…while循环

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

  1. object Test {
  2.    def main(args: Array[String]) {
  3.       // 局部变量
  4.       var a = 10;
  6.       // while 循环执行
  7.       while( a < 20 ){
  8.          println( "Value of a: " + a );
  9.          a = a + 1;
  10.       }
  11.    }
  12. }
  1. object Test {
  2.    def main(args: Array[String]) {
  3.       // 局部变量
  4.       var a = 10;
  6.       // do 循环
  7.       do{
  8.          println( "Value of a: " + a );
  9.          a = a + 1;
  10.       }while( a < 20 )
  11.    }
  12. }

对于Scala这种语言，更多的是应用于Spark这类的大数据场景下的，在这种场景下，不推荐使用while循环。因为 while语句不像for语句有yield，while没有返回值，所以当要用该语句来计算并返回结果时，就不可避免的要使用while外面定义的全局变量，这样就等同于循环内部的程序要操作外部的变量，对于大数据场景下不适用。而且while可以实现的功能，for语句都可以实现，所以推荐使用for循环。