Scala之for循环

for循环本质是一种遍历,遍历集合中的每个元素,当遍历完最后一个元素的时候,自动终止.

遍历字符串

val a = "abc" // 字符串

// 遍历容器. 变量c是常量, 不能修改
for (c <- a) {
  println(c)
}

结果

a
b
c

字符相加就变成int类型了

    val a = "abc" // 字符串

    // 遍历容器. 变量c是常量, 不能修改
    for (c <- a) {
      println(c + 0) //字符相加就变成了int类型了
    }

97
98
99

遍历数字

基本遍历

三种写法

    // 使用for输出 1-10
    // 1.to(10) 是获取到1~10的容器,简写是 1 to 10
    for (i <- 1.to(10)) {
      println(i)
    }

    //大于等于1,小于11
    for (i <- 1 until 11) { 
      println(i)
    }

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

得到的结果就是循环遍历1~10

1
2
3
4
5
6
7
8
9
10

获得奇数数字

    // 使用for输出 1-10的所有奇数
    for (i <- 1 to(10, 2)) { // to有两个参数: 参数1就是结束的值, 参数2是步长
     println(i)
    }
    //上面的简写
    for(i <- 1 to 10 by 2 ){
        println(i)
    }

输出

1
3
5
7
9

从10到1倒着输出

  // 使用for输出 10-1
    for (i <- 1 to 10 reverse) {
      println(i)
    }

另外一种写法

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

输出:

10
9
8
7
6
5
4
3
2
1

为true就进入循环体

保护式为true则进入循环体内部，为false则跳过，类似于continue。

输出1-10所有的奇数,如果i % 2 == 1 成立的话就输出

  for (i <- 1 to 10 if i % 2 == 1) {
      if (i % 2 == 1) {
        println(i)
      }
    }

另外一种写法,更简洁,但是我感觉可读性似乎变差.

    for (i <- 1 to 10 if i % 2 == 1) {
      println(i)
    }

1
3
5
7
9

关于代码的精简和可读性

输出1~100 的偶数 , j 是 两个i 相乘 ,只有j小于10000的时候输出j,如果j大于10000就不输出j

下面两个代码片段结果是一个结果,但是一个精简了,但是可读性差了,一个不精简,但是可读性好…

   for (i <- 1 to 100) {
      if (i % 2 == 0) {
        var j = i * i
        if (j < 10000) {
          println(s"i =$i , j = $j") 
        }
      }
    }

    for (i <- 1 to 100 if i % 2 == 0; j = i * i if j < 10000) {
      println(s"i =$i , j = $j")
    }

退出循环

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

不过这种方式性能不是特别好,点开看源码是自己抛出异常自己捕获的.

案例

break

循环遍历10以内的所有数据，数值为5，结束循环（break）

import scala.util.control.Breaks

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

    var n = 1

    Breaks.breakable {

      while (n < 10) {

        println("n=" + n)
        n += 1

        if (n == 5) {
          Breaks.break()
        }
      }
    }

    println("exit")
  }
}

输出

n=1
n=2
n=3
n=4
exit

continue

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

import scala.util.control.Breaks

object For3 {
  def main(args: Array[String]): Unit = {
    var n = 0
    while (n < 10) {

      Breaks.breakable {
        n += 1
        if (n % 2 != 0) {
          println(n)
        } else {
          println("continue")
          Breaks.break()
        }
      }
    }
  }
}

输出

1
continue
3
continue
5
continue
7
continue
9
continue

注意事项

（1）break：breakable放在循环外

（2）continue：breakable放在循环内

嵌套循环

（1）将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for，while，do…while均可以作为外层循环和内层循环。【建议一般使用两层，最多不要超过3层】

（2）实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。

（3）设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。

下面两个代码片段是一个作用,还是建议用第二种

第一种

    for (i <- 1 to 9; j <- 1 to i) {
      print(s"$j * $i = ${i * j}\t")
      if (i == j) println()
    }
  }

第二种

  for (i <- 1 to 9) {
      for (j <- 1 to i) {
        print(s"$j * $i = ${i * j}\t")
      }
      println()
    }

输出:

1 * 1 = 1	
1 * 2 = 2	2 * 2 = 4	
1 * 3 = 3	2 * 3 = 6	3 * 3 = 9	
1 * 4 = 4	2 * 4 = 8	3 * 4 = 12	4 * 4 = 16	
1 * 5 = 5	2 * 5 = 10	3 * 5 = 15	4 * 5 = 20	5 * 5 = 25	
1 * 6 = 6	2 * 6 = 12	3 * 6 = 18	4 * 6 = 24	5 * 6 = 30	6 * 6 = 36	
1 * 7 = 7	2 * 7 = 14	3 * 7 = 21	4 * 7 = 28	5 * 7 = 35	6 * 7 = 42	7 * 7 = 49	
1 * 8 = 8	2 * 8 = 16	3 * 8 = 24	4 * 8 = 32	5 * 8 = 40	6 * 8 = 48	7 * 8 = 56	8 * 8 = 64	
1 * 9 = 9	2 * 9 = 18	3 * 9 = 27	4 * 9 = 36	5 * 9 = 45	6 * 9 = 54	7 * 9 = 63	8 * 9 = 72	9 * 9 = 81	

循环返回值 yield

基本语法

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

println(res)

说明：将遍历过程中处理的结果返回到一个新Vector集合中，使用yield关键字,如果循环里面是多行代码的话,那么就返回最后一行代码的值

案例: 将原数据中所有值乘以2，并把数据返回到一个新的集合中。

    var res = for (i <- 1 to 10) yield {
      i * 2
    }
    println(res)

输出结果

Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)