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