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)