scala编程第17章学习笔记（1）——集合类型

列表

列表的初始化及对其首尾的访问：

scala> val colors = List("red", "blue", "green")
colors: List[String] = List(red, blue, green)

scala> colors.head
res15: String = red

scala> colors.tail
res16: List[String] = List(blue, green)

数组

建立长度已知但内容未知的数组：

scala> val fiveInts = new Array[Int](5)
fiveInts: Array[Int] = Array(0, 0, 0, 0, 0)

根据已知元素初始化数组：

scala> val fiveToOne = Array(5, 4, 3, 2, 1)
fiveToOne: Array[Int] = Array(5, 4, 3, 2, 1)

访问和更新数组元素：

scala> fiveInts(0) = fiveToOne(4)

scala> fiveInts
res18: Array[Int] = Array(1, 0, 0, 0, 0)

列表缓存

ListBuffer是可变对象（包含在scala.collection.mutable包中），它能够更高效地经过添加元素的方式构建列表。ListBuffer可以支持常量时间的添加和前缀操做。元素的添加使用+=操做符，前缀使用+：操做符。完成以后，能够经过ListBuffer调用toList方法得到List。举例以下：

scala> val buf = new ListBuffer[Int]
buf: scala.collection.mutable.ListBuffer[Int] = ListBuffer()

scala> buf += 1
res20: buf.type = ListBuffer(1)

scala> buf += 2
res21: buf.type = ListBuffer(1, 2)

scala> buf
res22: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2)

scala> 3 +: buf
res23: scala.collection.mutable.ListBuffer[Int] = ListBuffer(3, 1, 2)

scala> buf.toList
res24: List[Int] = List(1, 2)

数组缓存

ArrayBuffer与数组相似，只是额外还容许你在序列的开始或结束的地方添加和删除元素。全部的Array操做都被保留，只是因为实现中的包装层致使执行的稍微有些慢。

建立ArrayBuffer的时候，你必须指定它的类型参数，但能够不指定长度。ArrayBuffer能够自动调整分配的空间：

ArrayBuffer还能用+=操做添加元素：

scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer

scala> val buf = new ArrayBuffer[Int]()
buf: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

scala> buf += 12
res27: buf.type = ArrayBuffer(12)

scala> buf += 15
res29: buf.type = ArrayBuffer(12, 15)

全部数组能使用的方法数组缓存都能用。如能够得到ArrayBuffer的长度，或经过索引访问元素：

scala> buf.length
res30: Int = 2

scala> buf(0)
res31: Int = 12

队列
Scala的集合库提供了可变和不可变的Queue。如下方法建立空的不可变队列：

scala> import scala.collection.immutable.Queue
import scala.collection.immutable.Queue

scala> val empty = Queue[Int]()
empty: scala.collection.immutable.Queue[Int] = Queue()

可使用enqueue为不可变队列添加元素：

scala> val has1 = empty.enqueue(1)
has1: scala.collection.immutable.Queue[Int] = Queue(1)

若是要添加多个元素的话，能够把集合看成enqueue调用的参数：

scala> val has123 = has1.enqueue(List(2, 3))
has123: scala.collection.immutable.Queue[Int] = Queue(1, 2, 3)

从队列的头部移除元素，可使用dequeue：

scala> val (element, has23) = has123.dequeue
element: Int = 1
has23: scala.collection.immutable.Queue[Int] = Queue(2, 3)

对于不可变队列来讲，dequeue方法将返回由队列头部元素和移除该元素以后的剩余队列组成的对偶（Tuple2）。
可变队列的使用方式与不可变队列同样，只是代之以enqueue方法，可使用+=及++=操做符添加元素。还有，对于可变队列来讲，dequeue方法将只从队列移除头元素并返回。举例以下：

scala> import scala.collection.mutable.Queue
import scala.collection.mutable.Queue

scala> val queue = Queue[String]()
queue: scala.collection.mutable.Queue[String] = Queue()

scala> queue += "a"
res0: queue.type = Queue(a)

scala> queue ++= List("b", "c")
res1: queue.type = Queue(a, b, c)

scala> queue
res2: scala.collection.mutable.Queue[String] = Queue(a, b, c)

scala> queue.dequeue
res3: String = a

scala> queue
res4: scala.collection.mutable.Queue[String] = Queue(b, c)

栈

Stack一样在Scala的集合库中有可变和不可变两个版本。元素的推入使用push，弹出使用pop，只获取栈顶的元素而不移除可使用top。下面是使用可变栈的例子：

scala> import scala.collection.mutable.Stack
import scala.collection.mutable.Stack

scala> val stack = new Stack[Int]
stack: scala.collection.mutable.Stack[Int] = Stack()

scala> stack.push(1)
res5: stack.type = Stack(1)

scala> stack
res6: scala.collection.mutable.Stack[Int] = Stack(1)

scala> stack.push(2)
res7: stack.type = Stack(2, 1)

scala> stack
res8: scala.collection.mutable.Stack[Int] = Stack(2, 1)

scala> stack.top
res9: Int = 2

scala> stack
res10: scala.collection.mutable.Stack[Int] = Stack(2, 1)

scala> stack.pop
res11: Int = 2

scala> stack
res12: scala.collection.mutable.Stack[Int] = Stack(1)

字符串（经RichString隐式转换）

RichString也是应该知道的序列，它的类型是Seq[Char]。由于Predef包含了从String到RichString的隐式转换，因此你能够把任何字符串看成Seq[Char]。举例以下：

scala> def hasUpperCase(s:String) = s.exists(_.isUpper)
hasUpperCase: (s: String)Boolean

scala> hasUpperCase("Robert Frost")
res13: Boolean = true

scala> hasUpperCase("e e cummings")
res14: Boolean = false