For，Function，Lazy

 package com.dtgroup.study
 import scala.io.Source

 object ForFunctionLazy {
   def main(args: Array[String]): Unit = {
     // for
     println("for:line 0")
     for (i <- 1 to 2; j <- 1 to 2) println("i=" + i + ",j=" + j)
     println("for:line 1")
     for (i <- 1 to 2; j <- 1 to 2 if i == j) println("i=" + i + ",j=" + j)
     println("for:line 2")
     for (i <- 1 to 2; j <- 1 to 2 if i > j) println("i=" + i + ",j=" + j)
     println("for:line 3")
     for (i <- 1 to 2; j <- 1 to 2 if i != j) println("i=" + i + ",j=" + j)
     // error: for(i<- 1 to 2;j <-1 to 2 if i<>j) println("i="+i+",j="+j)

     // func:
     // 1,)the function with value
     // 2,)the scala ide known the result type
     // 3,)in the recursion must declare the result type.
     def add(x: Int) = x * 2
     // nickname function
     val add2 = (x: Int) => x * 200
     var i = 100;
     println("func:line 0")
     println(add(i))
     println("func:line 1")
     println(add2(i))

     def fac(n: Int): Int = if (n <= 0) 1 else n * fac(n - 1)
     println("func:line 2,The result from a fac is:" + fac(5))

     // the parameter of function can be assigned value
     def combine(content: String, left: String = "<", right: String = ">") = left + content + right
     println("func:line 3,The result from a combine is:" + combine("value"))
     println("func:line 4,The result from a combine is:" + combine("value", "[", "]"))

     // param[]
     def connected(args: Int*) = {
       var result = ""
       for (arg <- args) result += "," + arg.toString
       result
     }

     println("func:line 5,The result from a connected is:" + connected(1, 2, 3, 4, 5, 6))
     // lazy

     lazy val file = Source.fromFile("d:\\spark2.txt")
     println("lazy:line 0")
     for(line <- file.getLines()) println(line)
     println("lazy:line 1")
   }
 }

1，）for 中可以执行嵌套，同时可以加过滤条件；

2，）函数：

　　a,)不仅仅有返回值时也是可以不写的，编译器会自动识别类型，但是如果使用在递归函数中必须指明返回值；

　　b,)函数是有值的，从匿名函数中可以看出该结论；

　　c,)函数的参数可以制定默认值；

　　d,)函数的参数可以使用“类型*”，不限制传递参数个数；

3,)Lazy的用法，懒执行，只有当第一次使用时才加载，在scala中，对代码优化有极大贡献。