最近开始接触一点Scala的东西，这篇博客记录的都是一些最基本的Scala语法，主要是方便自己查询用，所以不是很系统。
目录
一、Scala 变量
在 Scala 中，使用关键词 "var" 声明变量，使用关键词 "val" 声明常量。鼓励使用val。
变量可以修改，而常量不可以修改。变量或函数的类型总是写在变量或函数名称后面，与Java的习惯不同。
var myVar : String = "Foo"
var myVar : String = "Too"当然，在没有指明数据类型的情况下，其数据类型是通过变量或常量的初始值推断出来的。
scala> val a=3
a: Int = 3在指明数据类型时，一定需要初始值，否则会报错。
Scala 多个变量声明如下：
val xmax, ymax = 100-
Scala 不需要使用分号最后，仅当同一行代码中存在多条语句时才需要分号隔开。
-
常用的数据类型与Java一样，Byte、Char、Short、Int、Long、Float、Double及Boolean，这些都是类。
二、控制结构
Scala中，几乎所有构造出来的语法结构都有值，不像Java中把表达式和语句（if语句）分为两类。
2.1 条件表达式
在Scala中if/else表达式有值，这个值就是在if或else之后的表达式的值。
1. scala> var x = 10
2. x: Int = 10
3.
4. scala> val r = if (x > 0) 1 else -1
5. r: Int = 1
6.
7. scala> var x = 0
8. x: Int = 0
9.
10. scala> val r = if (x > 0) 1 else -1
11. r: Int = -1
可能if没有输出值，但在Scala中，每个表达式都有某种值。
1. scala> var x = 0
2. x: Int = 0
3.
4. scala> val r = if (x > 0) 1
5. r: AnyVal = ()
2.2 块表达式和赋值
在Scala中{}块包含一系列表达式，其结果也是一个表达式。块中最后一个表达式的值就是块的值。
对于某个val的初始化需要分多步完成的情况很实用。
val dis = {val dx = x - x0; val dy = y - y0; sqrt(dx * dx + dy * dy)}2.3 循环
while与Java中的循环一样。
1. while(n > 0) {
2. r = r * n
3. n -= 1
4. }
Scala没有for(初始化; 检查变量是否满足; 更新变量)的结构。
1. for(i <- 1 to n) {
2. r = r * i
3. }
-
1 to n 表达式表示：返回数据1到n（包含）的区间。
-
1 until n 表达式表示：返回数据1到n（不包含）的区间。
2.4 增强for循环和for推导式
可以以变量<-表达式的形式提供多个生成器，用分号将他们隔开
1. scala> for(i <- 1 to 3; j <- 1 to 3) print ((10 * i + j) + " ")
2. 11 12 13 21 22 23 31 32 33
每个生成器都可以以if开头的Boolean表达式 (if前并没有分号)
1. scala> for(i <- 1 to 3; j <- 1 to 3 if i != j) print((10 * i + j) + " ")
2. 12 13 21 23 31 32
for推导式：for循环的循环以yield开始，则该循环会构造出一个集合，每次迭代生成集合中的一个值。
1. scala> for(i <- 1 to 10) yield i % 3
2. res2: scala.collection.immutable.IndexedSeq[Int] = Vector(1, 2, 0, 1, 2, 0, 1, 2, 0, 1)
三、Scala 方法与函数
Scala 有方法与函数，二者在语义上的区别很小。Scala 方法是类的一部分，而函数是一个对象可以赋值给一个变量。换句话来说在类中定义的函数即是方法。
Scala 中的方法跟 Java 的类似，方法是组成类的一部分。
Scala 中的函数则是一个完整的对象，Scala 中的函数其实就是继承了 Trait 的类的对象。
Scala 中使用 val 语句可以定义函数，def 语句定义方法
class Test{
def m(x: Int) = x + 3
val f = (x: Int) => x + 3
}3.1 方法
方法定义由一个 def 关键字开始，紧接着是可选的参数列表，一个冒号 : 和方法的返回类型，一个等于号 = ，最后是方法的主体。Scala 方法定义格式如下：
def functionName ([参数列表]) : [return type] = {
function body
return [expr]
}以上代码中 return type 可以是任意合法的 Scala 数据类型。参数列表中的参数可以使用逗号分隔。
以下方法的功能是将两个传入的参数相加并求和：
object add{
def addInt( a:Int, b:Int ) : Int = {
var sum:Int = 0
sum = a + b
return sum
}
}如果方法没有返回值，可以返回为 Unit，这个类似于 Java 的 void, 实例如下：
object Hello{
def printMe( ) : Unit = {
println("Hello, Scala!")
}
}3.2 函数
Scala 也是一种函数式语言，所以函数是 Scala 语言的核心。以下一些函数概念有助于我们更好的理解 Scala 编程：
3.2.1 指定函数参数名
1. scala> def decorate(str: String, left: String = "[", right: String = "]") = left + str + right
2. decorate: (str: String, left: String, right: String)String
3.
4. scala> decorate("Hello World")
5. res3: String = [Hello World]
6.
7. scala> decorate("Hello World", "<", ">")
8. res4: String = <Hello World>
也可以在提供参数值时指定参数名，这样就可与函数定义参数列表的顺序不一致
1. scala> decorate(left = "<<", str = "Hello Scala", right = ">>")
2. res5: String = <<Hello Scala>>
可以混用未命名参数和带名参数，只要未命名的参数排在前面即可
1. scala> decorate("Hello Spark", right = "]<<")
2. res6: String = [Hello Spark]<<
3.
4. 相当于
5.
6. scala> decorate("Hello Spark", "[", "]<<")
3.2.2 可变参数
Scala 允许指明函数的最后一个参数可以是重复的，即我们不需要指定函数参数的个数，可以向函数传入可变长度参数列表。
Scala 通过在参数的类型之后放一个星号来设置可变参数(可重复的参数)。例如：
object Test {
def main(args: Array[String]) {
printStrings("Runoob", "Scala", "Python");
}
def printStrings( args:String* ) = {
var i : Int = 0;
for( arg <- args ){
println("Arg value[" + i + "] = " + arg );
i = i + 1;
}
}
}执行以上代码，输出结果为：
$ scalac Test.scala
$ scala Test
Arg value[0] = Runoob
Arg value[1] = Scala
Arg value[2] = Python3.2.3 高阶函数
高阶函数（Higher-Order Function）就是操作其他函数的函数。
Scala 中允许使用高阶函数, 高阶函数可以使用其他函数作为参数，或者使用函数作为输出结果。
以下实例中，apply() 函数使用了另外一个函数 f 和 值 v 作为参数，而函数 f 又调用了参数 v：
object Test {
def main(args: Array[String]) {
println( apply( layout, 10) )
}
// 函数 f 和 值 v 作为参数，而函数 f 又调用了参数 v
def apply(f: Int => String, v: Int) = f(v)
// 将类型参数放置在名称之后，以方括号括起来。
def layout[A](x: A) = "[" + x.toString() + "]"
}执行以上代码，输出结果为：
$ scalac Test.scala
$ scala Test
[10]3.2.4 函数嵌套
我们可以在 Scala 函数内定义函数，定义在函数内的函数称之为局部函数。
以下实例我们实现阶乘运算，并使用内嵌函数：
object Test {
def main(args: Array[String]) {
println( factorial(0) )
println( factorial(1) )
println( factorial(2) )
println( factorial(3) )
}
def factorial(i: Int): Int = {
def fact(i: Int, accumulator: Int): Int = {
if (i <= 1)
accumulator
else
fact(i - 1, i * accumulator)
}
fact(i, 1)
}
}执行以上代码，输出结果为：
$ scalac Test.scala
$ scala Test
1
1
2
63.2.5 匿名函数
Scala 中定义匿名函数的语法很简单，箭头左边是参数列表，右边是函数体。
使用匿名函数后，我们的代码变得更简洁了。
下面的表达式就定义了一个接受一个Int类型输入参数的匿名函数:
var inc = (x:Int) => x+1以上实例的 inc 现在可作为一个函数，使用方式如下：
var x = inc(7)-1同样我们可以在匿名函数中定义多个参数：
var mul = (x: Int, y: Int) => x*ymul 现在可作为一个函数，使用方式如下：
println(mul(3, 4))我们也可以不给匿名函数设置参数，如下所示：
var userDir = () => { System.getProperty("user.dir") }userDir 现在可作为一个函数，使用方式如下：
println( userDir() )3.2.6 偏应用函数
Scala 偏应用函数是一种表达式，不需要提供函数需要的所有参数，只需要提供部分，或不提供所需参数。
如下实例，我们打印日志信息：
import java.util.Date
object Test {
def main(args: Array[String]) {
val date = new Date
log(date, "message1" )
Thread.sleep(1000)
log(date, "message2" )
Thread.sleep(1000)
log(date, "message3" )
}
def log(date: Date, message: String) = {
println(date + "----" + message)
}
}
执行以输出结果为：$ scalac Test.scala
$ scala Test
Mon Dec 02 12:52:41 CST 2018----message1
Mon Dec 02 12:52:41 CST 2018----message2
Mon Dec 02 12:52:41 CST 2018----message3实例中，log() 方法接收两个参数：date 和 message。我们在程序执行时调用了三次，参数 date 值都相同，message 不同。
我们可以使用偏应用函数优化以上方法，绑定第一个 date 参数，第二个参数使用下划线(_)替换缺失的参数列表，并把这个新的函数值的索引的赋给变量。以上实例修改如下：
import java.util.Date
object Test {
def main(args: Array[String]) {
val date = new Date
val logWithDateBound = log(date, _ : String)
logWithDateBound("message1" )
Thread.sleep(1000)
logWithDateBound("message2" )
Thread.sleep(1000)
logWithDateBound("message3" )
}
def log(date: Date, message: String) = {
println(date + "----" + message)
}
}执行以上代码，输出结果为：
$ scalac Test.scala
$ scala Test
Tue Dec 18 11:25:54 CST 2018----message1
Tue Dec 18 11:25:54 CST 2018----message2
Tue Dec 18 11:25:54 CST 2018----message33.2.7 函数柯里化(Currying)
柯里化(Currying)指的是将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数。
首先我们定义一个函数:
def add(x:Int,y:Int)=x+y那么我们应用的时候，应该是这样用：add(1,2)
现在我们把这个函数变一下形：
def add(x:Int)(y:Int) = x + y那么我们应用的时候，应该是这样用：add(1)(2),最后结果都一样是3，这种方式（过程）就叫柯里化。
实现过程
add(1)(2) 实际上是依次调用两个普通函数（非柯里化函数），第一次调用使用一个参数 x，返回一个函数类型的值，第二次使用参数y调用这个函数类型的值。
实质上最先演变成这样一个方法：
def add(x:Int)=(y:Int)=>x+y那么这个函数是什么意思呢？ 接收一个x为参数，返回一个匿名函数，该匿名函数的定义是：接收一个Int型参数y，函数体为x+y。现在我们来对这个方法进行调用。
val result = add(1) 返回一个result，那result的值应该是一个匿名函数：(y:Int)=>1+y
所以为了得到结果，我们继续调用result。
val sum = result(2)最后打印出来的结果就是3。
3.2.8 闭包
闭包是一个函数，返回值依赖于声明在函数外部的一个或多个变量。
闭包通常来讲可以简单的认为是可以访问一个函数里面局部变量的另外一个函数。
如下面这段匿名的函数：
val multiplier = (i:Int) => i * 10 函数体内有一个变量 i，它作为函数的一个参数。如下面的另一段代码：
val multiplier = (i:Int) => i * factor在 multiplier 中有两个变量：i 和 factor。其中的一个 i 是函数的形式参数，在 multiplier 函数被调用时，i 被赋予一个新的值。然而，factor不是形式参数，而是自由变量，考虑下面代码：
var factor = 3
val multiplier = (i:Int) => i * factor 这里我们引入一个自由变量 factor，这个变量定义在函数外面。
这样定义的函数变量 multiplier 成为一个"闭包"，因为它引用到函数外面定义的变量，定义这个函数的过程是将这个自由变量捕获而构成一个封闭的函数。
完整实例
object Test {
def main(args: Array[String]) {
println( "muliplier(1) value = " + multiplier(1) )
println( "muliplier(2) value = " + multiplier(2) )
}
var factor = 3
val multiplier = (i:Int) => i * factor
} 结果：
$ scalac Test.scala
$ scala Test
muliplier(1) value = 3
muliplier(2) value = 6 3.3 方法与函数区别
①函数可作为一个参数传入到方法中，而方法不行
object MethodAndFunctionDemo {
//定义一个方法
//方法 m1 参数要求是一个函数，函数的参数必须是两个Int类型
//返回值类型也是Int类型
def m1(f:(Int,Int) => Int) : Int = {
f(2,6)
}
//定义一个函数f1,参数是两个Int类型，返回值是一个Int类型
val f1 = (x:Int,y:Int) => x + y
//再定义一个函数f2
val f2 = (m:Int,n:Int) => m * n
//main方法
def main(args: Array[String]): Unit = {
//调用m1方法，并传入f1函数
val r1 = m1(f1)
println(r1)
//调用m1方法，并传入f2函数
val r2 = m1(f2)
println(r2)
}
}运行结果：
8
12②在Scala中无法直接操作方法，如果要操作方法，必须先将其转换成函数
查看以下代码
object TestMap {
def ttt(f:Int => Int):Unit = {
val r = f(10)
println(r)
}
//定义了一个函数
val f0 = (x : Int) => x * x
//定义了一个方法
def m0(x:Int) : Int = {
//传递进来的参数乘以10
x * 10
}
//将方法转换成函数，利用了神奇的下滑线。最常用的方法
val f1 = m0 _
def main(args: Array[String]): Unit = {
ttt(f0)
//通过m0 _将方法转化成函数
ttt(m0 _);
//如果直接传递的是方法名称，scala相当于是把方法转成了函数
ttt(m0)
//通过x => m0(x)的方式将方法转化成函数,这个函数是一个匿名函数，等价：(x:Int) => m0(x)
ttt(x => m0(x))
}
}输出结果为：
100
100
100
100③函数必须要有参数列表，而方法可以没有参数列表
四、Scala 数组
-
长度固定使用Array，长度有变化使用ArrayBuffer
-
提供初始值时不要使用new
-
用()来访问元素
-
for(elem <- arr)遍历元素
-
for(elem <- arr if ...) yield ...将原数组转为新数组
4.1 定长数组
10个整数的数组，所有元素初始为0
1. scala> val nums = new Array[Int](10)
2. nums: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
10个元素的字符中数组，所有元素初始化为null
1. scala> val str = new Array[String](10)
2. str: Array[String] = Array(null, null, null, null, null, null, null, null, null, null)
提供初始值就不需要new，长度为2的Array[String]，类型是推断出来的
1. scala> val str1 = Array("Hello", "Scala")
2. str1: Array[String] = Array(Hello, Scala)
使用()来访问元素
1. scala> val s = str1(0)
2. s: String = Hello
4.2 变长数组
-
与Java中ArrayList功能等效的数据结构ArrayBuffer
-
初始化一个空的可变长数组，准备存入整数
1. scala> import scala.collection.mutable.ArrayBuffer
2. import scala.collection.mutable.ArrayBuffer
3.
4. scala> val b = ArrayBuffer[Int]()
5. b: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()
用+=在尾添加元素或多个用括号包都来的元素
1. scala> b += 1
2. res0: b.type = ArrayBuffer(1)
3.
4. scala> b += (1, 2, 3)
5. res1: b.type = ArrayBuffer(1, 1, 2, 3)
用++=操作符追加任何集合
1. scala> b ++= Array(6, 8, 9)
2. res2: b.type = ArrayBuffer(1, 1, 2, 3, 6, 8, 9)
移除最后2个元素
1. scala> b.trimEnd(2)
2.
3. scala> b
4. res4: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 1, 2, 3, 6)
可在任意位置插入或移除元素（不高效，所有在那个位置后面的元素都必须被平移）
1. // 在下标2之前插入
2. scala> b.insert(2, 4)
3.
4. scala> b
5. res6: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 1, 4, 2, 3, 6)
定长数组与变长数据转换
1. // 转成定长数组
2. scala> b.toArray
3. res9: Array[Int] = Array(1, 1, 4, 5, 4, 2, 3, 6)
4.
5.
6. // 转成变长数组
7. scala> b.toBuffer
8. res10: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 1, 4, 5, 4, 2, 3, 6)
4.3 遍历数组
1. // 使用下标访问
2. scala> for (i <- 0 until b.length)
3. | println(i + ":" + b(i))
4. 0:1
5. 1:1
6. 2:4
7. 3:5
8. 4:4
9. 5:2
10. 6:3
11. 7:6
12.
13. // 不使用下标
14. scala> for(elem <- b)
15. | println(elem)
16. 1
17. 1
18. 4
19. 5
20. 4
21. 2
22. 3
23. 6
4.4 多维数组
多维数组一个数组中的值可以是另一个数组，另一个数组的值也可以是一个数组。矩阵与表格是我们常见的二维数组。
以上是一个定义了二维数组的实例：
import Array._
var myMatrix = ofDim[Int](3,3)实例中数组中包含三个数组元素，每个数组元素又含有三个值。
接下来我们来看一个二维数组处理的完整实例：
import Array._
object Test {
def main(args: Array[String]) {
var myMatrix = ofDim[Int](3,3)
// 创建矩阵
for (i <- 0 to 2) {
for ( j <- 0 to 2) {
myMatrix(i)(j) = j;
}
}
// 打印二维阵列
for (i <- 0 to 2) {
for ( j <- 0 to 2) {
print(" " + myMatrix(i)(j));
}
println();
}
}
}4.5 Scala 数组方法
当然，数组还有很多操作，如合并数组，创建区间数组等。
Scala 数组中记录了Scala 的常用数组方法。
五、Scala 字符串
5.1 创建字符串
val greeting: String = "Hello,World!"以上实例定义了变量 greeting，为字符串常量，它的类型为 String (java.lang.String)。
在 Scala 中，字符串的类型实际上是 Java String，它本身没有 String 类。
在 Scala 中，String 是一个不可变的对象，所以该对象不可被修改。这就意味着如果修改字符串就会产生一个新的字符串对象。
但其他对象，如数组就是可变的对象。
如果需要创建一个可以修改的字符串，可以使用 String Builder 类，如下实例:
object Test {
def main(args: Array[String]) {
val buf = new StringBuilder;
buf += 'a'
buf ++= "bcdef"
println( "buf is : " + buf.toString );
}
}执行以上代码，输出结果为：
$ scalac Test.scala
$ scala Test
buf is : abcdef创建格式化字符串
String 类中可以使用 printf() 方法来格式化字符串并输出
object Test {
def main(args: Array[String]) {
var floatVar = 12.456
var intVar = 2000
var stringVar = "aaa!"
var fs = printf("浮点型变量为 " +
"%f, 整型变量为 %d, 字符串为 " +
" %s", floatVar, intVar, stringVar)
println(fs)
}
}执行以上代码，输出结果为：
$ scalac Test.scala
$ scala Test
浮点型变量为 12.456000, 整型变量为 2000, 字符串为 aaa5.2 String 方法
String中有许多方法，如length() 求字符串长度，concat() 拼接字符串。
var palindrome = "www.runoob.com";
var len = palindrome.length();
println( "String Length is : " + len );结果
String Length is : 14Scala 字符串中记录了java.lang.String 中常用的方法。
六、Scala 集合(Collection)
Scala提供了一套很好的集合实现，提供了一些集合类型的抽象。
Scala 集合分为可变的和不可变的集合。
可变集合可以在适当的地方被更新或扩展。这意味着可以修改，添加，移除一个集合的元素。
而不可变集合类，相比之下，永远不会改变。不过，然可以模拟添加，移除或更新操作。但是这些操作将在每一种情况下都返回一个新的集合，同时使原来的集合不发生改变。
接下来介绍几种常用集合类型的应用。
6.1 Scala List(列表)
Scala 列表类似于数组，它们所有元素的类型都相同，但是它们也有所不同：列表是不可变的，值一旦被定义了就不能改变，其次列表 具有递归的结构（也就是链接表结构）而数组不是。。
列表的元素类型 T 可以写成 List[T]。
Scala List(列表)中记录了List常用方法。
6.2 Scala Set(集合)
Scala Set(集合)是没有重复的对象集合，所有的元素都是唯一的。
Scala 集合分为可变的和不可变的集合。
默认情况下，Scala 使用的是不可变集合，如果想使用可变集合，需要引用 scala.collection.mutable.Set 包。
默认引用 scala.collection.immutable.Set.
Scala Set(集合)中记录了Set常用方法。
6.3 Scala Map(映射)
Map(映射)是一种可迭代的键值对（key/value）结构。所有的值都可以通过键来获取。
Map 中的键都是唯一的。Map 也叫哈希表（Hash tables）。
Map 有两种类型，可变与不可变，区别在于可变对象可以修改它，而不可变对象不可以。
默认情况下 Scala 使用不可变 Map。如果需要使用可变集合，你需要显式的引入 import scala.collection.mutable.Map 类
在 Scala 中可以同时使用可变与不可变 Map，不可变的直接使用 Map，可变的使用 mutable.Map。
Scala Map(映射)中记录了Map常用方法。
6.4 Scala 元组
与列表一样，元组也是不可变的，但与列表不同的是元组可以包含不同类型的元素。
Scala 元组中记录了元组常用方法。
6.5 Scala Option(选项)
Scala Option(选项)类型用来表示一个值是可选的（有值或无值)。
Option[T] 是一个类型为 T 的可选值的容器： 如果值存在， Option[T] 就是一个 Some[T] ，如果不存在， Option[T] 就是对象 None 。
接下来来看一段代码：
// 虽然 Scala 可以不定义变量的类型，不过为了清楚些，我还是
// 把他显示的定义上了
val myMap: Map[String, String] = Map("key1" -> "value")
val value1: Option[String] = myMap.get("key1")
val value2: Option[String] = myMap.get("key2")
println(value1) // Some("value1")
println(value2) // None在上面的代码中，myMap 一个是一个 Key 的类型是 String，Value 的类型是 String 的 hash map，但不一样的是 get() 返回的是一个叫 Option[String] 的类别。
Scala 使用 Option[String] 来告诉你：「我会想办法回传一个 String，但也可能没有 String 给你」。
myMap 里并没有 key2 这笔数据，get() 方法返回 None。
Option 有两个子类别，一个是 Some，一个是 None，当他回传 Some 的时候，代表这个函式成功地给了一个 String，可以透过 get() 这个函式拿到那个 String，如果他返回的是 None，则代表没有字符串可以给你。
另一个实例：
object Test {
def main(args: Array[String]) {
val sites = Map("runoob" -> "www.runoob.com", "google" -> "www.google.com")
println("sites.get( \"runoob\" ) : " + sites.get( "runoob" )) // Some(www.runoob.com)
println("sites.get( \"baidu\" ) : " + sites.get( "baidu" )) // None
}
}执行以上代码，输出结果为：
$ scalac Test.scala
$ scala Test
sites.get( "runoob" ) : Some(www.runoob.com)
sites.get( "baidu" ) : None你也可以通过模式匹配来输出匹配值。实例如下：
object Test {
def main(args: Array[String]) {
val sites = Map("runoob" -> "www.runoob.com", "google" -> "www.google.com")
println("show(sites.get( \"runoob\")) : " +
show(sites.get( "runoob")) )
println("show(sites.get( \"baidu\")) : " +
show(sites.get( "baidu")) )
}
def show(x: Option[String]) = x match {
case Some(s) => s
case None => "?"
}
}执行以上代码，输出结果为：
$ scalac Test.scala
$ scala Test
show(sites.get( "runoob")) : www.runoob.com
show(sites.get( "baidu")) : ?Scala Option(选项)中记录了Option常用方法。
6.6 Scala Iterator（迭代器）
Scala Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法。
迭代器 it 的两个基本操作是 next 和 hasNext。
调用 it.next() 会返回迭代器的下一个元素，并且更新迭代器的状态。
调用 it.hasNext() 用于检测集合中是否还有元素。
让迭代器 it 逐个返回所有元素最简单的方法是使用 while 循环：
object Test {
def main(args: Array[String]) {
val it = Iterator("Baidu", "Google", "Runoob", "Taobao")
while (it.hasNext){
println(it.next())
}
}
}执行以上代码，输出结果为：
$ scalac Test.scala
$ scala Test
Baidu
Google
Runoob
TaobaoScala Iterator（迭代器）中记录了Iterator常用方法。
七、Scala 类和对象
这个自己暂时还用不到，先不写了。
包括其它的，如Scala Trait(特征)等。回头需要了再更。
参考文献
【1】Scala 教程
【2】Scala快速入门系列
723
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
