Scala笔记（一）：Array，List，Tuple，Set，Map，Iterator

1. 数组(Array)

数组是编程中经常用到的数据结构，Scala中包括定长数组（Array）和变长数组（ArrayBuffer）。
定长数组，就是长度不变的数组，在Scala中使用Array进行声明，如下：

val intArr = new Array[Int](2)   //定义长度为2的整型数组，整型默认初始化为0，字符串为null（空）
intArr(0) = 12  //给第1个数组元素赋值为12
intArr(1) = 45   //给第2个数组元素赋值为45
for (i <- 0 to 1) println(intArr(i))  //对数组元素的引用，是圆括号，而不是方括号

Scala也提供了更加简洁的数组声明和初始化方法，如下：

val intArr = Array(12,45)
val myStrArr = Array("BigData","Hadoop","Spark")
  --------------------
import scala.collection.mutable.ArrayBuffer //变长数组的依赖包
val array = ArrayBuffer[String]() //空字符串数组
array += ("a","bc","def")  //增加元素

从上面代码可见，在定义时不需要给出数组类型，Scala会自动根据提供的初始化数据来推断出数组的类型。

2. 列表(List)

在Spark学习中，经常会用到列表，声明一个列表：

val intList = List(1,2,3)

列表有头部和尾部的概念，可以使用intList.head来获取上面定义的列表的头部，值是1，使用intList.tail来获取上面定义的列表的尾部，值是List(2,3），头部是一个元素，而尾部则仍然是一个列表。
由于列表的头部是一个元素，所以，可以使用::操作，在列表的头部增加新的元素，得到一个新的列表：

val intList = List(1,2,3)
val intListOther = 0::intList

intListOther是一个新的列表List(0,1,2,3)。要构建一个列表List(1,2,3)，实际上也可以采用下面的方式：

val intList =1::2::3::Nil  //Nil表示空列表。 

使用:::操作符对不同的列表进行连接得到新列表，如：

val intList1 = List(1,2)
val intList2 = List(3,4)
val intList3 = intList1:::intList2

Scala为列表提供了一些常用的方法，如实现求和，可以直接调用sum方法:

intList.sum

3. 元组(Tuple)

元组是不同类型的值的集合。元组和列表/数组不同，列表/数组中各个元素必须是相同类型，而元组可以包含不同类型的元素。
声明一个名称为tuple的元组）：

val tuple = ("BigData",2015,45.0)
println(tuple._1)  //BigData
println(tuple._2)  //2015

声明一个元组用圆括号把多个元组的元素包围起来就可以，当需要访问元组中的某个元素的值时，可以通过类似tuple._1、tuple._2这种方式就可以实现。

4. 集(Set)

集(set)是不重复元素的集合。列表中的元素是按照插入的先后顺序来组织的，但是，”集”中的元素并不会记录元素的插入顺序，而是以“哈希”方法对元素的值进行组织，所以，它允许你快速地找到某个元素。
集包括可变集和不可变集，缺省情况下创建的是不可变集，通常使用不可变集。
用默认方式创建一个不可变集：

var mySet = Set("Hadoop","Spark")
mySet += "Scala"  //向mySet中增加新的元素
println(mySet.contains("Scala")) //true

上面声明时，如果使用val，mySet += “Scala”执行时会报错，所以需要声明为var。
如果要声明一个可变集，则需要引入scala.collection.mutable.Set包，具体如下（在Scala解释器中执行）：

import scala.collection.mutable.Set
val myMutableSet = Set("Database","BigData")
myMutableSet += "Cloud Computing"
println(myMutableSet)   // Set(BigData, Cloud Computing, Database)

上面代码中，声明myMutableSet为val变量（不是var变量），由于是可变集，因此，可以正确执行myMutableSet += “Cloud Computing”，不会报错。
注意：虽然可变集和不可变集都有添加或删除元素的操作，但是，二者有区别：对不可变集进行操作，会产生一个新的集，原来的集不变。 而对可变集进行操作，改变的是该集本身。

5. 映射(Map)

在Scala中，映射(Map)是一系列键值对的集合，也就是，建立了键和值间对应关系。在映射中，所有的值，都可以通过键来获取。
映射包括可变和不可变两种，默认情况下创建的是不可变映射，如果需要创建可变映射，需要引入scala.collection.mutable.Map包。
创建一个不可变映射：

val university = Map("XMU" -> "Xiamen University", "THU" -> "Tsinghua University","PKU"->"Peking University")

如果要获取映射中的值，可以通过键来获取，如下：

println(university("XMU"))

上面代码通过”XMU”这个键，可以获得值Xiamen University。
如果要检查映射中是否包含某个值，可以使用contains方法，如下：

val xmu = if (university.contains("XMU")) university("XMU") else 0
println(xmu)

定义的不可变映射，无法更新映射中的元素，也无法增加新元素。如果要更新映射的元素，就需要定义一个可变的映射，如下：

import scala.collection.mutable.Map
val university2 = Map("XMU" -> "Xiamen University", "THU" -> "Tsinghua University","PKU"->"Peking University")
university2("XMU") = "Ximan University" //更新已有元素的值
university2("FZU") = "Fuzhou University" //添加新元素

也可以使用+=操作来添加新的元素：

university2 + = ("TJU"->"Tianjin University") //添加一个新元素
university2 + = ("SDU"->"Shandong University","WHU"->"Wuhan University") //同时添加两个新元素

循环遍历映射，是经常需要用到的操作，基本格式是：
for ((k,v) <- 映射) 语句块

for ((k,v) <- university) printf("Code is : %s and name is: %s\n",k,v)

上面代码执行结果如下：

Code is : XMU and name is: Xiamen University
Code is : THU and name is: Tsinghua University
Code is : PKU and name is: Peking University

或者，也可以只遍历映射中的k或者v，打印所有键或值：

for (k<-university.keys) println(k)
for (v<-university.values) println(v)

6. 迭代器(Iterator)

在Scala中，迭代器（Iterator）不是一个集合，但是，提供了访问集合的一种方法。当构建一个集合需要很大的开销时（比如把一个文件的所有行都读取内存），迭代器就可以发挥很好的作用。 迭代器包含两个基本操作：next和hasNext。next可以返回迭代器的下一个元素，hasNext用于检测是否还有下一个元素。
有了这两个基本操作，就可以顺利地遍历迭代器中的所有元素。通常可以通过while循环或者for循环实现对迭代器的遍历。
while循环如下：

val iter = Iterator("Hadoop","Spark","Scala")
while (iter.hasNext) {
    println(iter.next())
}

注意，上述操作执行结束后，迭代器会移动到末尾，就不能再使用了，如果继续执行一次println(iter.next)就会报错。代码中，使用iter.next和iter.next()都是可以的，但是，hasNext后面不能加括号。
for循环如下：

val iter = Iterator("Hadoop","Spark","Scala")
for (elem <- iter) {
    println(elem)
}