1. intersect方法找出两个字符串的相同字符：
scala> "Hello".intersect("World")
res3: String = lo
2. for推导式生成的集合与它的第一个生成器的类型是兼容的。
scala> for(c <- "Hello";i <- 0 to 1) yield (c + i).toChar
res7: String = HIeflmlmop scala> for(i <- 0 to 1; c <- "Hello") yield (c + i).toChar
res9: scala.collection.immutable.IndexedSeq[Char] = Vector(H, e, l, l, o, I, f,
m, m, p)
3. 变长参数
scala> def sum(args: Int*) = {
| var result = 0
| for (arg <- args) result += arg
| result
| }
sum: (args: Int*)Int
scala> val s = sum(1, 3, 4, 5, 32)
s: Int = 45
scala> def recursiveSum(args: Int*): Int = {
| if(args.length == 0) 0
| else args.head + recursiveSum(args.tail: _*)
| }
recursiveSum: (args: Int*)Int
scala> recursiveSum(1 to 5: _*)
res10: Int = 15
在这里，序列的head是它的首个元素，而tail是所有其他元素的序列，这又是一个Seq，我们用：_*来将它转换成参数序列。
4. 过程
Scala对于不返回值的函数有特殊的表示法。如果函数体包含在花括号当中但没有前面的=号，那么返回值类型就是Unit。这样的函数被称做过程（procedure）。过程不返回值，我们调用它仅仅是为了它的副作用。例如：
scala> def box(s: String) {
| var border = "-" * s.length + "--\n"
| println(border + "|" + s + "|\n" + border)
| }
box: (s: String)Unit
scala> box("Hello")
-------
|Hello|
-------
5. 变长数组：数组缓冲
scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer scala> val b = ArrayBuffer[Int]()
b: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer() scala> b += 1
res15: b.type = ArrayBuffer(1) scala> b += (1, 2, 3, 5)
res16: b.type = ArrayBuffer(1, 1, 2, 3, 5) scala> b ++= Array(8, 13, 21)
res17: b.type = ArrayBuffer(1, 1, 2, 3, 5, 8, 13, 21)
scala> b.trimEnd(5) //移除最后5个元素
scala> b
res19: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 1, 2)
你也可以在任意位置插入或移除元素，但这样的操作并不那么高效——所有在那个位置之后的元素都必须被平移。举例如下：
scala> b.insert(2,6) //在下标2之前插入 scala> b
res21: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 1, 6, 2) scala> b.insert(2,7,8,9) //可以插入任意多的元素 scala> b
res23: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 1, 7, 8, 9, 6,
2) scala> b.remove(2)
res24: Int = 7 scala> b
res25: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 1, 8, 9, 6, 2) scala> b.remove(2,3) //第2个参数的含义是要移除多少个元素 scala> b
res27: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 1, 2)
有时候你需要构建一个Array，但不知道最终需要装多少元素。这种情况下，先构建一个数组缓冲，然后调用：
scala> b.toArray
res28: Array[Int] = Array(1, 1, 2)
反过来，调用a.toBuffer可以将一个数组a转换成一个数组缓冲。
6. 数组转换
从一个数组（或数组缓冲）出发，以某种方式对它进行转换是很简单的。这些转换动作不会修改原始数组，而是产生一个全新的数组。
像这样使用for推导式：
scala> val a = Array(2, 3, 5, 7, 11)
a: Array[Int] = Array(2, 3, 5, 7, 11) scala> val result = for(elem <- a) yield 2*elem
result: Array[Int] = Array(4, 6, 10, 14, 22)
for(...)yield循环创建了一个类型与原始集合相同的新集合。如果你从数组出发，那么你得到的是另一个数组。如果你从数组缓冲出发，那么你在for(...)yield之后得到的也是一个数组缓冲。
另一种做法是：
scala> a.filter(_ % 2 == 0).map(2 * _)
res34: Array[Int] = Array(4) scala> a.filter(_ % 2 == 0) map(2 * _)
res35: Array[Int] = Array(4)
7. 多维数组
和java一样，多维数组是通过数组来实现的。举例来说，Double的二维数组类型为Array[Array[Double]]。要构建这样一个数组，可以用ofDim方法：
scala> val matrix = Array.ofDim[Double](3, 4) //三行，四列
matrix: Array[Array[Double]] = Array(Array(0.0, 0.0, 0.0, 0.0), Array(0.0, 0.0,0.0, 0.0), Array(0.0, 0.0, 0.0, 0.0))
要访问其中的元素，使用两对圆括号：
scala> matrix(0)(0) = 42 scala> matrix
res2: Array[Array[Double]] = Array(Array(42.0, 0.0, 0.0, 0.0), Array(0.0, 0.0, 0.0, 0.0), Array(0.0, 0.0, 0.0, 0.0))
你可以创建不规则的数组，每一行的长度各不相同：
scala> val triangle = new Array[Array[Int]](10)
triangle: Array[Array[Int]] = Array(null, null, null, null, null, null, null, null, null, null) scala> for(i <- 0 until triangle.length)
| triangle(i) = new Array[Int](i + 1) scala> triangle
res4: Array[Array[Int]] = Array(Array(0), Array(0, 0), Array(0, 0, 0), Array(0, 0, 0, 0), Array(0, 0, 0, 0, 0), Array(0, 0, 0, 0, 0, 0), Array(0, 0, 0, 0, 0, 0, 0), Array(0, 0, 0, 0, 0, 0, 0, 0), Array(0, 0, 0, 0, 0, 0, 0, 0, 0), Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
8. 与Java的互操作
由于Scala数组是用Java数组实现的，你可以在Java和Scala之间来回传递。可以引入scala.collection.JavaConversions里的隐式转换方法。这样你就可以在代码中使用Scala缓冲，在调用Java方法时，这些对象会被自动包装成Java列表。
举例来说，java.lang.ProcessBuilder类有一个以List<Sring>为参数的构造器。以下是在scala中调用它的写法：
scala> import scala.collection.JavaConversions.bufferAsJavaList
import scala.collection.JavaConversions.bufferAsJavaList scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer scala> val command = ArrayBuffer("ls","-al","/home/cay")
command: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(ls, -al, /home/cay) scala> val pb = new ProcessBuilder(command) //Scala到Java的转换
pb: ProcessBuilder = java.lang.ProcessBuilder@b37537
Scala缓冲被包装成了一个实现了java.util.List接口的Java类的对象。
反过来讲，当Java方法返回java.util.List时，我们可以让它自动转换成一个Buffer：
scala> import scala.collection.JavaConversions.asScalaBuffer
import scala.collection.JavaConversions.asScalaBuffer scala> import scala.collection.mutable.Buffer
import scala.collection.mutable.Buffer scala> val cmd: Buffer[String] = pb.command() //Java到Scala的转换
cmd: scala.collection.mutable.Buffer[String] = ArrayBuffer(ls, -al, /home/cay)
//不能使用ArrayBuffer——包装起来的对象仅能保证是个Buffer
如果Java方法返回一个包装过的Scala缓冲，那么隐式转换会将原始的对象解包出来。拿本例来说，cmd == command。
9. 获取映射中的值
scala> val scores = Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8)
scores: scala.collection.immutable.Map[String,Int] = Map(Alice -> 10, Bob -> 3,
Cindy -> 8)
scala> val scores = scala.collection.mutable.Map("Alice" -> 10, "Bob" -> 3, "Can
dy" -> 8)
scores: scala.collection.mutable.Map[String,Int] = Map(Bob -> 3, Alice -> 10, Ca
ndy -> 8)
scala> val scores = new scala.collection.mutable.HashMap[String,Int]
scores: scala.collection.mutable.HashMap[String,Int] = Map()
scala> "Alice" -> 10
res5: (String, Int) = (Alice,10)
scala> scores
res6: scala.collection.mutable.HashMap[String,Int] = Map()
scala> val scores = Map(("Alice", 10), ("Bob", 3), ("Cindy", 8)
| )
scores: scala.collection.immutable.Map[String,Int] = Map(Alice -> 10, Bob -> 3,
Cindy -> 8)
scala> val bobsScore = scores("Bob")
bobsScore: Int = 3
scala> val bobsScore = if(scores.contains("Bob")) scores("Bob") else 0
bobsScore: Int = 3
由于这样的组合调用十分普遍，以下是一个快捷的写法：
scala> val bobsScore = scores.getOrElse("Bob", 0)
bobsScore: Int = 3
//如果映射包含键“Bob”，返回对应的值；否则，返回0。