scala 数据结构

1. 容器

mutable 可变

immutable 不可变

2. 列表

2.1 列表声明与构建

列表是一种共享相同类型的不可变的对象序列，声明时必须初始化。

var strList = List("one", "two", "three", "four")
// 取列表首元素
println(strList.head)
println(strList(0))
// one
println(strList.tail)
// List(two, three, four)
// 取列表最后一个元素
println(strList(strList.length-1))
// four
println(strList.reverse)
// List(four, three, two, one)

列表构建

在已有列表前端增加元素

var newList = "zero"::strList
// List(zero, one, two, three, four)

val a1 = List(1,2,3)
等价于
val a2 = 1::2::3::Nil

3. 集合

集合是不重复元素的容器，以“哈希”方法对元素的值进行组织（元素无序）可以快速地找到某个元素。（列表查找复杂度o(n)，集合查找复杂度o(1)）。

集合包括可变集合与不可变集合，缺省情况下是不可变集。

3.1 不可变集合

var myset = Set("one", "two")
// 这里可以执行成功，因为myset是可变的，相当于生成了一个新的集合，（myset前后指向的是不同的集合）
myset += "five"
println(myset)
// Set(one, two, five)

3.2 可变集合

import scala.collection.mutable.Set

val myset = Set("one", "two")
// 这里虽然myset是不可变的，但集合是可变的，myset前后指向的是同一个集合
myset += "five"
println(myset)
// Set(one, two, five)

4. 映射

map 与set一样也分为可变与不可变两种，缺省情况下不可变。map 可以根据键来对值进行快速的检索。

4.1 不可变map

无法更新元素，也无法增加元素。

var mymap = Map("one"->1, "two"->2)
// 增加元素，生成了一个新的map
mymap += ("five"->5)
// mymap("one") = 11  会报错，无法修改元素！！！
println(mymap)
// Map(one -> 1, two -> 2, five -> 5)
// 查找元素
println(mymap("five"))
// 5
// 是否包含某个键，键不存在会抛出异常
println(mymap.contains("five"))
// true

4.2 可变map

import scala.collection.mutable.Map

val mymap = Map("one"->1, "two"->2)
// 增加元素，还是同一个map
mymap += ("four"->4,"five"->5)
// 修改元素
mymap("one") = 11
println(mymap)
// Map(one -> 11, four -> 4, five -> 5, two -> 2)

4.3 遍历map

var mymap = Map("one"->1, "two"->2)
for((k,v) <- mymap)
    println(k,v)
for(k <- mymap.keys)
    println(k)
for(v <- mymap.values)
    println(v)
// map长度
println(mymap.size)

5. 迭代器

iter 不是一个集合，但提供了访问集合的一种方法。

5.1 遍历迭代器

val iter = Iterator("one", "two", "three")
for(e <- iter){
    println(e)
}

while(iter.hasNext){
    println(iter.next())
}

5.2 grouped方法返回元素的增量分块

val mylist = List(1, 2, 3, 4, 5)
val git = mylist.grouped(3)
// val git = mylist grouped 3
println(git)
// non-empty iterator
println(git.next())
// List(1, 2, 3)
println(git.next())
// List(4, 5)

5.3 sliding方法生成一个滑动元素的窗口

val mylist = List(1, 2, 3, 4, 5)
val sit = mylist.sliding(3)
println(sit)
// non-empty iterator
println(sit.next())
// List(1, 2, 3)
println(sit.next())
// List(2, 3, 4)
println(sit.next())
// List(3, 4, 5)

6. 数组

数组是一种可变的，可索引的，元素具有相同类型的数据集合。

6.1 数组定义与遍历

val arr = new Array[Int](3)
arr.foreach(print)
// 000 每个数组元素初始化为0
arr(0) = 1

for(i <- 0 until arr.size)
    println(arr(i))
for(i <- 0 to arr.size-1)
    println(arr(i))
for(e <- arr)
    println(e)

// 自动推断数组类型
val bb = Array(11, 22, 33)

6.2 多维数组

// 二维数组
val bb = Array.ofDim[Int](3,4)
bb(1)(2) = 123

// 三维数组
val bb = Array.ofDim[String](2,3, 2)
bb(1)(1)(1) = "boy"

6.3 不定长数组

使用Array类型定义的数组，属于定长数组，其长度在初始化后就不能改变。

使用ArrayBuffer类型可以定义变长数组。

val aa = ArrayBuffer(10, 20, 30)
aa += 40
println(aa)
// ArrayBuffer(10, 20, 30, 40)
// 从第二个位置起插入50，60
aa.insert(2,50,60)
println(aa)
// ArrayBuffer(10, 20, 50, 60, 30, 40)
aa -= 40
println(aa)
// ArrayBuffer(10, 20, 50, 60, 30)
aa.remove(1)
println(aa)
// ArrayBuffer(10, 50, 60, 30)

7. 元组

元组是不同类型的值的聚集（元组中元素类型可以不同，但数组中必须相同）。

val aa = ("boy", 17, 123.4)
// 取第一个元素
println(aa._1)
// boy