Scala字符串与容器
String
前文已经说明了字符串的声明方式:
var s = "Hello World";
var s: String = "Hello World";
在 Scala 中，字符串的类型实际上是 Java String(java.lang.String)，它本身没有 String 类。我们可以在Scala中使用Java String的所有方法。
String对象是不可变对象， 更改String内容的操作实际上是创建了一个新的字符串。
scala> var s = "Hello";
res: s: String = Hello
scala> s.charAt(0);
res: Char = H
scala> s.length();
res: Int = 5
scala> var f = "%s, %d";
f: String = %s, %d
scala> f.format("Hello", 1);
res: String = Hello, 1
scala> s + f;
res: String = Hello%s, %d
若需要创建一个可以修改的字符串，可以使用 String Builder 类：
scala> var sb = new StringBuilder();
sb: StringBuilder =
scala> sb ++= "Hello" // ++= for string
res: StringBuilder = Hello
scala> sb += ',' // += for char
res: StringBuilder = Hello,
scala> println(sb)
Hello,
scala> println(sb.toString)
Hello,
Array
Array是scala内置的数组类型，用于线性存储同类型对象， 其长度不可变， 实际上是Java Array。
scala> var arr = new Array[Int](3)
arr: Array[Int] = Array(0, 0, 0)
scala> var arr = Array("Hello", "World") // do not use `new`
arr: Array[String] = Array(Hello, World)
scala> var arr = Array.range(1,3) // range(satrt, stop, step)
arr: Array[Int] = Array(1, 2)
scala> var dim = Array.ofDim[Int](3, 3) // multi dim array
arr: Array[Array[Int]] = Array(Array(0, 0, 0), Array(0, 0, 0), Array(0, 0, 0))
scala使用圆括号而非方括号访问数组元素， 下标从0开始:
scala> arr(0)
res: Int = 0
scala> arr(0) = 1
scala> arr(0)
res: Int = 1
scala> dim(0)(1)
res: Int = 0
ArrayBuffer
ArrayBuffer是scala提供的变长数组， 使用前需要先进行引入:
scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer
scala> var ab = new ArrayBuffer[Int]()
ab: ArrayBuffer[Int] = ArrayBuffer()
scala> var ab = ArrayBuffer(1,2,3,4)
ab: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4)
ArrayBuffer的初始化与操作与Array很像。
scala> ab(1)
res: Int = 2
scala> ab(1) = 3
scala> ab(1)
res: Int = 3
变长数组ArrayBuffer可以任意添加删除元素：
scala> ab
res: ArrayBuffer[Int] = ArrayBuffer(1, 2)
scala> ab += 3 // append element
res: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3)
scala> ab += (4, 5) // use tuple append several elements
res: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 5)
scala> ab ++= Array(6, 7) // use array append several elements
res: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 5, 6, 7)
scala> ab ++= List(8, 9) // use list append several elements
res: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9)
insert方法可以在任意位置插入元素：
scala> ab.insert(0,0) // insert 0 at index 0
res: ArrayBuffer[Int] = ArrayBuffer(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
scala> ab.insert(1, 3, 4, 5) // insert several elements
res: ArrayBuffer[Int] = ArrayBuffer(0, 3, 4, 5, 1, 2, 3, 4, 5, 6, 7, 8, 9)
remove(index)方法可以移除指定位置的单个元素并返回被移除元素的值.
remove(start, len) 方法可以移除从start位置开始的len个元素, 即下标在范围内[start, start+len]的元素。
scala> ab.remove(0) // remove element, `remove` will return the element
res: Int = 0
scala> ab
res: ArrayBuffer[Int] = ArrayBuffer(3, 4, 5, 1, 2, 3, 4, 5, 6, 7, 8, 9)
scala> ab.remove(0, 3)
res: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9)
Array与ArrayBuffer之间可以互相转换：
scala> ab.toArray
res: Array[Int] = Array(1, 2, 3, 4)
scala> arr.toBuffer
res: Buffer[Int] = ArrayBuffer(1, 2, 3, 4)
List
List是scala中的另一个线性容器，其数据结构为广义表。List是线性存储同类型对象的定长容器，其元素不可改变。
List也可以用构造函数或字面值初始化:
scala> var l1 = List(1,2,3)
l: List[Int] = List(1, 2, 3)
scala> var l2 = 4::5::6::Nil
l: List[Int] = List(4, 5, 6)
scala> var l = List.range(1,4)
l: List[Int] = List(1, 2, 3)
Nil是scala的保留字代表一个空List， 这里可以暂时理解为结尾标记。待下文说明List的广义表结构和::运算符之后，我们就会更深入地理解第二种初始化方式。
List的操作与Array类似， 但是元素无法更改：
scala> l1(1)
res: Int = 2
scala> l1.length
res: Int = 3
scala> l1.isEmpty
res: Boolean = false
scala> l1(2) = 2
<console>: error: value update is not a member of List[Int]
List提供了广义表的head和tail操作， head操作返回List的第一个元素，返回从第二个元素到最后一个元素组成的列表。
scala> l1.head
res: Int = 1
scala> l1.tail
res: List[Int] = List(2, 3)
每一个List都可以看做由head和tail两部分组成， head::tail即是将head和tail组装为List的运算符. ::在tail为单个元素e时， 将其作为List(e)处理.
而运算符:::用于连接两个List.
scala> l1 :: l2
res: List[Any] = List(List(1, 2, 3), 4, 5, 6)
scala> l1:::l2
res: List[Int] = List(1, 2, 3, 4, 5, 6)
scala> Nil
res: scala.collection.immutable.Nil.type = List()
List可以与其他线性容器相互转换:
scala> l.toString()
res: String = List(1, 2, 3)
scala> l.toArray
res: Array[Int] = Array(1, 2, 3)
scala> l.toBuffer
res: Buffer[Int] = ArrayBuffer(1, 2, 3)
Tuple
元组(tuple)与List类似同为不可变线性容器， 元组的特点在于它可以容纳不同类型的元素。
元组可以使用圆括号字面值创建：
scala> var tu = (1, "Hello", 2.0)
tu: (Int, String, Double) = (1,Hello,2.0)
访问tuple元素的方法比较独特:
scala> tu._1
res: Int = 1
scala> tu._2
res: String = Hello
scala> tu._3
res: Double = 2.0
Set
集合(Set)是不允许元素重复的无序的容器， scala中的集合默认为不可变集合scala.collection.immutable.Set, 若需要使用可变集合需要手动引入scala.collection.mutable.Set.
可变与不可变集合均实现了添加删除元素以及合并集合等操作， 只不过不可变集合执行此类操作时创建了一个新的集合，而可变集合改变了自身。
scala> var s = Set(1,2,3)
s: Set[Int] = Set(1, 2, 3)
scala> s(0) // if `0` in s then return true else return false
res: Boolean = false
scala> s(1)
res: Boolean = true
scala> s = s + 4 // add a new element to a set
s: Set[Int] = Set(1, 2, 3, 4)
scala> s = s - 4 // remove an element from a set
s: Set[Int] = Set(1, 2, 3)
上述Set的运算符均有对应的复合赋值运算符， 如+=添加元素.
scala也提供了一些集合之间的运算， 包括交集，并集和差集:
scala> var s2 = Set(2, 3, 4)
s2: Set[Int] = Set(2, 3, 4)
scala> s & s2 // intersect
res: Set[Int] = Set(2, 3)
scala> s | s2 // union
res: Set[Int] = Set(1, 2, 3, 4)
scala> s &~ s2 // difference
res: Set[Int] = Set(1)
Map
映射(Map)是存储键值对的无序容器，Map中的键都是唯一的其某些特性与Set类似。
Scala同样拥有可变Map和不可变Map，默认引入的是不可变Map， 若需使用可变Map可以自行导入。
scala实现了Map的常用操作:
scala> var m = Map("one"->1, "two"->2)
m: Map[String,Int] = Map(one -> 1, two -> 2)
scala> m.contains("three") // check whether a key contains
res: Boolean = false
scala> m("one") // get value from key
res: Int = 1
scala> "three" -> 3 // make a key-value pair
res: (String, Int) = (three,3)
scala> m += ("three" -> 3) // add a key-value pair
m: Map[String,Int] = Map(one -> 1, two -> 2, three -> 3)
scala> m ++= Map("four"->4) // ++ for map
m: Map[String,Int] = Map(one -> 1, three -> 3, four -> 4)
scala> m -= "two" // remove a key-value pair
m: Map[String,Int] = Map(one -> 1, three -> 3)
上述复合运算符均有对应的算术运算符, 如m - "two"移除键值对.
我们也可以访问Map的keys和values集合：
scala> m.keys
res: Iterable[String] = Set(one, three)
scala> m.values
res: Iterable[Int] = MapLike.DefaultValuesIterable(1, 3)
