scala命令

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。