数据结构

容器（collection）抽象类

包括列表、数组、集合、映射等；可以分为有序和无序，可变和不可变

scala.collection、scala.collection.mutable和scala.collection.immutable

列表

不可变，在声明时必须初始化

列表头部和尾部：head和tail

head返回第一个值，tail返回除第一个元素外的值构成的新列表

val s = List(1,2,3,4,5)
s.head
s.tail
val a = "hh"::s //在已有列表前端添加元素，右结合：：，原列表对象不变
val b = 1::2::3::Nil //Nil是空列表对象
val b = List(1,2,3)

集合

集合（set）内的元素是不重复的。不会记录元素的插入顺序，以哈希方法对元素的值进行组织

集合包括可变和不可变两种形式。

缺省情况下是不可变：(不导入任何包的默认情况下)

var myset = Set("q",'b')
myset += "c"
//可变
import scala.collection.mutable.Set
val mymutableset = Set("b","a")
mymutableset += "c"

映射

键值对，键是唯一的但值不一定是唯一的。

可变和不可变映射

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

println(university("XMU"))

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)

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

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

迭代器

不是一个集合，但是可访问集合。

next返回迭代器的下一个元素，hasNext用于检测是否还有下一个元素

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

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

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

有两个方法返回迭代器：grouped和sliding，返回原容器元素的全部子序列。

grouped返回元素的增量分块，sliding生成一个滑动元素的窗口

val xs = List(1,2,3,4,5)
val git = xs grouped 3
git.next()
     List[Int] = List(1, 2, 3)
git.next()
      List[Int] = List(4, 5)
val git = xs sliding 3
git.next()
      List[Int] = List(1, 2, 3)
git.next()
      List[Int] = List(2, 3, 4)
git.next()
      List[Int] = List(3, 4, 5)

数组

可变可索引，元素具相同类型的数据集合。

val intValueArr = new Array[Int](3)  //声明一个长度为3的整型数组，每个数组元素初始化为0
intValueArr(0) = 12 //给第1个数组元素赋值为12
intValueArr(1) = 45  //给第2个数组元素赋值为45
intValueArr(2) = 33 //给第3个数组元素赋值为33

val myStrArr = new Array[String](3) //声明一个长度为3的字符串数组，每个数组元素初始化为null
myStrArr(0) = "BigData"
myStrArr(1) = "Hadoop"
myStrArr(2) = "Spark"
for (i <- 0 to 2) println(myStrArr(i)) 

val intValueArr = Array(12,45,33)
val myStrArr = Array("BigData","Hadoop","Spark")

//定义多维数组
val aa = Array.ofDim[Int](3,4)
val bb = Array.ofDim[String](3,2,4)
//使用多级（）来访问，比如aa(0)(1)

//定义变长数组
import scala.collection.mutable.ArrayBuffer
val aMutableArr = ArrayBuffer(10,20,30)
aMutableArr += 40
aMutableArr.insert(2,60)#在第三个位置插入60
aMutableArr -= 40
var temp = aMutableArr.remove(2)

元组

元组是不同类型的值的聚集。元组可以包含不同类型的元素。

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