[原创]Scala学习：for，function，lazy

1.for循环是一个循环控制结构，可以有效地编写需要执行的特定次数的循环。Scalar的循环说明如下的各种形式：

1）Scala中for循环最简单的语法是：

　　for( var x <- Range ){
   　　statement(s);
　　}

　　在这里，范围可能是一个数字范围，并且表示为i到j或有时像i到j左箭头  < - 操作者被称为生成器，这样命名是因为它是从一个范围产生单个数值。

2）for循环中，循环将遍历给定范围内的所有可能的计算，可以使用分号 (;) 分隔多个范围。下面是使用两个范围的例子，也可以使用两个以上的范围。

object Test {
   def main(args: Array[String]) {
      var a = 0;
      var b = 0;
      // for loop execution with a range
      for( a <- 1 to 3; b <- 1 to 3){
         println( "Value of a: " + a );
         println( "Value of b: " + b );
      }
   }
}

3）for 循环使用过滤器

Scala for循环允许过滤出使用一个或多个某些元素if语句（多个）。以下是对用于沿使用过滤器循环的语法。

for( var x <- List
      if condition1; if condition2...
   ){
   statement(s);
}

要添加多个过滤器到一个for表达式，分离过滤用分号（;）。

例子：

以下是for循环使用滤器的例子：

object Test {
   def main(args: Array[String]) {
      var a = 0;
      val numList = List(1,2,3,4,5,6,7,8,9,10);

      // for loop execution with multiple filters
      for( a <- numList
           if a != 3; if a < 8 ){
         println( "Value of a: " + a );
      }
   }
}

4)for循环采用yield：

可以从存储中返回for循环中的变量的值，也可以通过函数返回。要做到这一点，可以通过关键字yield前缀的for表达式体，如下所示：

var retVal = for{ var x <- List
     if condition1; if condition2...
}yield x

注意在大括号已被用来保持变量和条件以及retVal的是其中x的所有值将被储存在收集的形式的变量。

例子：

以下为例子，说明了for循环及yield的用法：

object Test {
   def main(args: Array[String]) {
      var a = 0;
      val numList = List(1,2,3,4,5,6,7,8,9,10);

      // for loop execution with a yield
      var retVal = for{ a <- numList
                        if a != 3; if a < 8
                      }yield a

      // Now print returned values using another loop.
      for( a <- retVal){
         println( "Value of a: " + a );
      }
   }
}

2.Function(函数)：基本定义，匿名函数，递归函数，参数必须设置类型

1）Scala函数定义有如下形式：

def functionName ([list of parameters]) : [return type] = {
   function body
   return [expr]
}

在这里，返回类型可以是任何有效的scala数据类型，参数列表将是用逗号和参数，返回值类型列表分离变量是可选的。非常类似于Java，一个返回语句可以在函数表达式可用情况下返回一个值。以下是这将增加两个整数并返回的函数：

object add{
   def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a + b

      return sum
   }
}

 1 package first.scala
 2
 3 object For_Function_Advanced {
 4
 5
 6   def main(args: Array[String]): Unit = {
 7
 8
 9     for(i <- 1 to 2; j <- 1 to 2) print((100 *  i + j) + " ")
10     println()
11
12     //很常见，带有条件判断的 for 循环
13     for(i <- 1 to 2; j <- 1 to 2 if i != j ) print((100 *  i + j) + " ")
14     println()
15
16
17
18     //函数
19     //函数有值，函数可以作为函数的参数去传递
20
21     def add(x: Int) = x +100
22     val add2 = (x: Int) => x + 100
23
24     println(add(5))
25     println(add2(10))
26
27     //递归函数必须指明函数的返回值
28     def fac(n: Int): Int = if(n <= 0) 1 else n * fac(n-1)
29     println(fac(10))
30
31     //函数的默认参数
32     def combine(content : String ,left : String = "[" , right : String =  "]"  ) = left + right
33     println(combine("i love jason"))
34
35
36     //函数的参数可变
37     def connected(args: Int*) = {
38       var result = 0;
39       for(arg <- args) result += arg
40       result
41     }
42
43
44 println(connected(1,2,3,4,5))
45
46
47
48
49
50   }
51
52 }

关于lazy

 1 package first.scala
 2
 3 import scala.io.Source
 4
 5 object lazyOps {
 6   def main(args: Array[String]): Unit = {
 7
 8     //lazy 修饰的变量或者常量，只有在第一次被使用的时候，它才被实例化。懒执行，
 9     lazy val file = Source.fromFile("E:\\test.txt")
10     for(line <- file.getLines()) println(line)
11   }
12 }