黑猴子的家：Scala for 表达式

Scala 也为for 循环这一常见的控制结构提供了非常多的特性，这些for 循环的特性被称为for 推导式（for comprehension）或for 表达式（for expression）。

1、遍历array1 里面所有的元素

val array1 = Array(1,"2","3",true)
for (x <- array1){
  //println(x + " -> " + ((x getClass) getTypeName))
  println(x + " -> " + x.getClass.getTypeName)
}

2、for循环遍历下标

for(x <- 0 to array1.length - 1) println(array1(x))
for(x <- 0 until array1.length) println(array1(x))

3、for示例 “to”

//[1,10]  前闭后闭
for(x <- 1 to 10){
  println(x);
}

for(i <- 1 to 3; j <- 1 to 3){
  println(i * j + " ")
}
println()

#### 4、for示例  “until” 
//until [1,10) 前闭后开
for(x <- 1 until 10){
  println(x)
}

for(x <- 1.until(10)){
  print(x)
}

for(i <- 1 until 3; j <- 1 until 3) {
  print(i * j + " ")
}
println()

5、for示例 “引入守卫模式”

也称条件判断式、保护式、满足为true则进入循环内部，满足为false则跳过，类似于continue

//scala 不需要continue，因为scala 有守护模式
for(x <- 1 to 10 if x != 5) print(x + " ")

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

//守卫模式  当 x 符合不等五的条件就执行，当等于5 这一次不执行
for(x <- 1 to 10 if x != 5){
  print(x + " ")
}

println()

//java 中的 continue 模式， 在scala 中不需要
/*for{var i = 0;i <= 10; i+=1}{
  if (i == 5){
    continue;
  }
  println(i);
}*/

6、for示例 “引入变量”

//for 引入变量
for(x <- 1 to 10 ; y = x - 1){
   print(y + " ")
}
println()

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

7、for示例 “{}”

使用花括号{}代替小括号()

//for () 变 {} 不在一行可以省略";"
//案例一
for{
  x <- 1 to 10
  y = x - 1
  z = y * 2
}{
  print(z + " ")
}

//案例二
for{
  i <- 1 to 3
  j = 4 – i
}
  print(i * j + " ")
println()

//案例三
//for () 变 {} 不在一行可以省略";"
for{
  x <- 1 to 10 ; y = x -1
  z = y * 2
}{
  print(z + " ")
}

//for 循环中 () -> {}  之间的转化，可以看做是把函数作为参数专递
//最简单的匿名函数，有几个参数，就是function几
// 比如说有二个参数，就是<function2>
val tem1 = () => 1 + 2
val tem2 = (x:Int) => 1 + 2
println(tem1)
println(tem1())
println(tem2)
println(tem2(1))

尖叫提示：{}和()对于for表达式来说都可以。for 推导式有一个不成文的约定：当for 推导式仅包含单一表达式时使用原括号，当其包含多个表达式时使用大括号。值得注意的是，使用原括号时，早前版本的Scala 要求表达式之间必须使用分号。

8、for示例 “yield”

将遍历过程中处理的结果返回到一个集合当中，使用yield关键字

案例一
// yield 关键字：如果for循环的循环体，以yield关键字开始，则该循环会构造出一个集合，
// 这类循环叫做for的推导式，生成的集合与它的第一个生成器是类型兼容的
/*  通过java实现这样的一个功能，要写这么多代码，scala 只需要一句话就可以了
public List<String> getList(List<String> list){
  List<String> resultlist = new ArrayList();
  for(String x : list){
    String tempstring = x.replaceAll(" ","")
    resultlist.add(tempstring)
  }
  return resultlist
}*/
val array2 = Array(1,2,3,4,5)
var result1 = (for(x <- array2) yield x+1)
println(result1)
println(result1.mkString(" "))
println(result1.getClass)
println(result1.getClass.getTypeName)

案例二
val for5 = for(i <- 1 to 10) yield i
println(for5)

案例三
val array3 = Array(1,2,3,4,5)
val result5 = for(x <- array3) yield x + 1
println(result5.getClass.getTypeName+result5.mkString(" "))
println(result5)

案例四
//5 scala Object
//scala 最终都会编译成.class 文件，所以混合类型是Object
//java 的强大是可以和Scala 无缝对接,还可以通过Java  的JNI技术可以和 C++ 无缝对接
//混合编程在国外是很流行的
val array3 = Array(1,"2",true)
val result2 = for(x <- array3) yield x
println(result2.getClass.getTypeName)

案例五
val array4 = Array(1,2,3,"km",true)
val result6 = for(x <- array4) yield x
println(result6.getClass.getTypeName+result6.mkString(" "))
println(result6)

//案例六
//yield生成的集合与它的第一个生成器是类型兼容的
val na1 = for(c <- "Hello";i <- 0 to 1) yield (c + i).toChar
val na2 = for(i <- 0 to 1 ; c <- "Hello") yield (c + i).toChar
println(na1)
println(na2)

9、矩形

一个for循环实现了2个for循环或3个for循环

//打印矩形
for(x <- 1 to 5; y <- 1 to 5){
  print("*")
  if(y == 5) println
}

//体验嵌套for循环
for(x <- 1 to 10; y <- 1 to 10; z <- 1 to 10){
  println(x + "," + y + "," + z)
}

10、for 的break

//scala中并没有提供break或者continue语句来退出循环
//如果需要break时，我们该怎么办呢？？
//（1） 使用Boolean 型的控制变量
//（2）使用嵌套函数 -> 你可以从函数当中return
//（3）使用Breaks 对象中的break方法
import scala.util.control.Breaks._
breakable{
  for (x <- 1 to 10){
     if (x == 5){
        break
     }
     print(x)
   }
}
//在这里，控制权的转移是通过抛出和捕获异常完成的，因此，如果时间很重要的话，应该尽量避免使用这套机制

11、for 演示局部变量冲突

//在 Java 中 ,你不能再重叠的作用域内使用同名的两个局部变量
//在 Scala中，没有这个限制，正常的遮挡规则会生效，例如，下边的代码是完全合法的
val n = 3
for(n <- 1 to 10){
  println(n)
}
println(n)

12、for 遍历Map 集合

for 循环遍历Map 有8到9种之多，在此就不一一列举了，会在Map章节中单独讲解

//对偶 -> Tuple
//Tuple 最多可以传递22个元素
//Tuple就是存一些临时的，如果你想用Tuple存很多数据，使用Tuple嵌套就好了
for (x <- map1){
   println(x)
}

for((k,v) <- map1){
   println(k + "->" + v)
}

尖叫提示：学会了scala语言的for遍历Map后，我们来看一下Kotlin语言，Kotlin是2011年诞生的，已经成为Android官方编程语言，Kotlin语言也是变异成 .class 文件，语法和Scala差不多

13、for 打印1到10 和 10到1数组

for (x <- 1 to 10 reverse){
  print(x + " ")
}


for(x <- 1.to(10).reverse){
  print(x + " ")
}

尖叫提示：Scala中，所有的调用都是函数调用，只不过它的点是可以省略的，让常见的逻辑操作更容易理解了

转载于:https://www.jianshu.com/p/7ea9b82d63d9