[原创]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 }

 

转载于:https://www.cnblogs.com/jasonHome/p/5731095.html