本文共 6016 字，大约阅读时间需要 20 分钟。
前文已经说明了字符串的声明方式:
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 = Helloscala> s.charAt(0);res: Char = Hscala> s.length();res: Int = 5scala> var f = "%s, %d";f: String = %s, %dscala> f.format("Hello", 1);res: String = Hello, 1scala> s + f;res: String = Hello%s, %d 若需要创建一个可以修改的字符串，可以使用 String Builder 类：
scala> var sb = new StringBuilder();sb: StringBuilder =scala> sb ++= "Hello" // ++= for stringres: StringBuilder = Helloscala> sb += ',' // += for charres: StringBuilder = Hello,scala> println(sb)Hello,scala> println(sb.toString)Hello,
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 arrayarr: Array[Array[Int]] = Array(Array(0, 0, 0), Array(0, 0, 0), Array(0, 0, 0)) scala使用圆括号而非方括号访问数组元素， 下标从0开始:
scala> arr(0)res: Int = 0scala> arr(0) = 1scala> arr(0)res: Int = 1scala> dim(0)(1)res: Int = 0
ArrayBuffer是scala提供的变长数组， 使用前需要先进行引入:
scala> import scala.collection.mutable.ArrayBufferimport scala.collection.mutable.ArrayBufferscala> 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 = 2scala> ab(1) = 3scala> ab(1)res: Int = 3
变长数组ArrayBuffer可以任意添加删除元素：
scala> abres: ArrayBuffer[Int] = ArrayBuffer(1, 2)scala> ab += 3 // append elementres: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3)scala> ab += (4, 5) // use tuple append several elementsres: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 5)scala> ab ++= Array(6, 7) // use array append several elementsres: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 5, 6, 7)scala> ab ++= List(8, 9) // use list append several elementsres: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9)
insert方法可以在任意位置插入元素：
scala> ab.insert(0,0) // insert 0 at index 0res: ArrayBuffer[Int] = ArrayBuffer(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)scala> ab.insert(1, 3, 4, 5) // insert several elementsres: 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 elementres: Int = 0scala> abres: 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.toArrayres: Array[Int] = Array(1, 2, 3, 4)scala> arr.toBufferres: Buffer[Int] = ArrayBuffer(1, 2, 3, 4)
List是scala中的另一个线性容器，其数据结构为广义表。List是线性存储同类型对象的定长容器，其元素不可改变。
List也可以用构造函数或字面值初始化:
scala> var l1 = List(1,2,3)l: List[Int] = List(1, 2, 3)scala> var l2 = 4::5::6::Nill: 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 = 2scala> l1.lengthres: Int = 3scala> l1.isEmptyres: Boolean = falsescala> l1(2) = 2: error: value update is not a member of List[Int]
List提供了广义表的head和tail操作， head操作返回List的第一个元素，返回从第二个元素到最后一个元素组成的列表。
scala> l1.headres: Int = 1scala> l1.tailres: List[Int] = List(2, 3)
每一个List都可以看做由head和tail两部分组成， head::tail即是将head和tail组装为List的运算符. ::在tail为单个元素e时， 将其作为List(e)处理.
而运算符:::用于连接两个List.
scala> l1 :: l2res: List[Any] = List(List(1, 2, 3), 4, 5, 6)scala> l1:::l2res: List[Int] = List(1, 2, 3, 4, 5, 6)scala> Nilres: scala.collection.immutable.Nil.type = List()
List可以与其他线性容器相互转换:
scala> l.toString()res: String = List(1, 2, 3)scala> l.toArrayres: Array[Int] = Array(1, 2, 3)scala> l.toBufferres: Buffer[Int] = ArrayBuffer(1, 2, 3)
元组(tuple)与List类似同为不可变线性容器， 元组的特点在于它可以容纳不同类型的元素。
元组可以使用圆括号字面值创建：
scala> var tu = (1, "Hello", 2.0)tu: (Int, String, Double) = (1,Hello,2.0)
访问tuple元素的方法比较独特:
scala> tu._1res: Int = 1scala> tu._2res: String = Helloscala> tu._3res: Double = 2.0
集合(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 falseres: Boolean = falsescala> s(1)res: Boolean = truescala> s = s + 4 // add a new element to a sets: 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 // unionres: Set[Int] = Set(1, 2, 3, 4)scala> s &~ s2 // differenceres: Set[Int] = Set(1)
映射(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 = falsescala> m("one") // get value from keyres: Int = 1scala> "three" -> 3 // make a key-value pairres: (String, Int) = (three,3)scala> m += ("three" -> 3) // add a key-value pairm: Map[String,Int] = Map(one -> 1, two -> 2, three -> 3)scala> m ++= Map("four"->4) // ++ for mapm: Map[String,Int] = Map(one -> 1, three -> 3, four -> 4)scala> m -= "two" // remove a key-value pairm: Map[String,Int] = Map(one -> 1, three -> 3) 上述复合运算符均有对应的算术运算符, 如m - "two"移除键值对.
我们也可以访问Map的keys和values集合：
scala> m.keysres: Iterable[String] = Set(one, three)scala> m.valuesres: Iterable[Int] = MapLike.DefaultValuesIterable(1, 3)
转载地址：http://ymqzz.baihongyu.com/