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)
