晓新's Blog

Scala数组，映射，元组

数组

  • 若长度固定则使用Array，若长度可能变化则使用ArrayBuffer。
  • 提供初始值时不要使用new。
  • 用()来访问元素。
  • 用for(elem <- arr)来遍历元素。
  • 用for(elem <- arr if expression) yield expression来将元数组转型为新数组。
  • scala数组可以和java数组互操作，用ArrayBuffer，使用scala.collection.JavaConversions中的转换函数。

定长数组

val nums = new Array[Int](10)
val s = Array("hello","world")//提供初始值不需要new，并且类型可以推断出来。
s(0) = "goodbye"

在jvm中，scala的Array以java数组方式实现。

变长数组：数组缓冲

import scala.collection.mutable.ArrayBuffer
val b = ArrayBuffer[Int]()
b += (1,2,3,4)
b ++= Array(1,2,3)
b.trimEnd(5)//移除最后5个元素。
b.insert(2,3,4,5)//在下标2之前插入3,4,5。
b.remove(2,3)//移除从下标2开始的3个元素。

有时候，你需要构建一个Array，但不知道最终需要装多少个元素，在这种情况下，先构成一个数组缓冲，然后调用：

b.toArray
//反过来，你也可以将Array转换成数组缓冲
a.toBuffer

数组转换

val a = Array(2,3,4,5)
val result = for(elem <- a if elem % 2 == 0) yield 2 *elem
//守卫+yield的方式也可以用filter+map的方式实现
a.filter(_ % 2 == 0).map( 2 * _)

常用算法

val a = Array(1,7,2,9)
val b = a.max/sum
val c = a.sorted

可以提供一个比较函数，不过你需要用sortWith函数：

val d = b.sortWith(_ > _)

如果你想显示数组/数组缓冲的内容，可以用mkString方法，它允许你指定元素之间的分隔符。

a.mkString("-")//用-分隔数组元素，组成一个字符串。

多维数组

可以用ofDim方法来构造多维数组:

val matrix = Array.ofDim[Double](3,4)
matrix(1)(2) = 3.0

你可以创建不规则的数组，每一行长度各不相同：

val matrix2 = new Array[Array[Int]](10)
for(i <- 0 until matrix2.length)
    matrix2(i) = new Array[Int](i+1)

与java的互操作

scala的数组使用java数组实现的，你可以在java和scala之间来回传递。 你需要引入scala.collection.JavaConversions里的隐式转换。这样你就可以将scala的数组缓冲传递到接收java数组的函数中去了。

import scala.collection.JavaConversions.bufferAsJavaList
import scala.collection.mutable.ArrayBuffer
val command = ArrayBuffer("ls","-al","/home/cay")
val pb = new ProcessBuilder(command)
//将scala 转换成java

映射和元组

  • 你需要从可变和不可变的映射中做出选择。
  • 默认情况下，你得到的是一个哈希映射，不过你也可以指明要树形映射。
  • 可以方便的从scala映射和java映射之间来回切换。

构造映射

val scores = Map("Alice" -> 10,"Bob" -> 3,"Candy" -> 8)
val scores2 = new scala.collection.mutable.Map("Alice" -> 10,"Bob" -> 3,"Candy" -> 8)
val scores3 = Map(("Alice",10),("Bob",3),("Candy",8))

获取映射的值

val Bobscore = scores("Bob")
val Alicescore = scores.getOrElse("Bob",0)

get(key)函数返回一个Option对象，要么是Some(键对应的值)，要么是None。

更新映射中的值

在可变map中，可以添加新的关系，也可以删除关系。

scores2("Bob") = 10
scores2 += ("Fred" -> 11)
scores2 -= "Alice"

你不能更新一个不可变map，但是也可以做一些有用的操作，例如，利用一个不可变map生成一个新的map。

val newscores = scores + ("Bob" -> 14,"Fred" -> 9)

迭代映射

for((k,v) <- scores)
for(v <- scores.values)
for(k <- scores.keySet)

已排序映射

如果你需要顺序的访问所有的键，你需要声明一个树形映射，而默认是一个哈希表。

val scores3 = scala.collections.immutable.SortedMap("Alice" -> 10,"Bob" -> 3,"Candy" -> 8)

元组

元组是不同类型的值的集合。

val t = (1,3.14,"Fred")
val second = t._2//访问第二个元素，元素是从1开始的，这点跟数组不同。
val (first,second,third) = t
val (first,second,_) = t

zip函数

val symbols = Arary("<","-",">")
val counts = Array(2,10,2)
val pairs = symbols .zip(counts)
//Array(("<",2),("-",10),(">",2))

还有一种常用的用例，是用toMap函数把对偶的集合转换成映射。

keys.zip(values).toMap

Comments !