scala之映射和元组

构造映射

映射是键/值对偶的集合。Scala有一个通用的叫法-元组-n个对象的聚集，并不一定要相同的类型。对偶不过是一个n=2的元组。我们可以通过以下方式构造映射，如

  1.构建不可变映射

scala> val map = Map("a" -> 1, "b" -> 2)
map: scala.collection.immutable.Map[String,Int] = Map(a -> 1, b -> 2)

注：上述代码构造了一个不可变的Map[String, Int]-对偶类型Scala会自动推导，其值不能被改变。你可以通过 -> 操作符来创建对偶。你也可以通过Map(("a", 1), ("b", 2))来创建对偶。

  2.构建可变映射

val res = scala.collection.mutable.Map("a" -> 1, "b" -> 2)
res: scala.collection.mutable.Map[String,Int] = Map(b -> 2, a -> 1)

注：上述代码构建了一个可变的Map[String, Int]，其值可以被改变。Scala可以推导出Map对偶的类型，但是如果为Map()，则会生成一个可变的Map[Nothing, Nothing]。
  3.构建空映射

scala> val res = new scala.collection.mutable.HashMap[String, Int]
res: scala.collection.mutable.HashMap[String,Int] = Map()

注：上述代码构建了一个空映射。

---

获取映射中的值

在Scala中，你要使用()表示法来查找某个键对应的值。如，

scala> val map = scala.collection.mutable.Map("a" -> "a", "b" -> "b")
map: scala.collection.mutable.Map[String,String] = Map(b -> b, a -> a)

scala> map("a")
res0: String = a

注：如果映射并不包含请求中使用的键，则会抛出异常。如果你要检查映射中是否包含某个指定的键，可用contains方法。映射中有一个getOrElse方法，有则取对应key值，否则取默认值，如.getOrElse("c", "t")，调用返回字符串t。在Scala中，映射.get(键)这样的调用返回一个Option对象，要么是Some(键对应的值)，要么是None。

---

更新映射中的值 

在可变映射中，你可以更新某个映射的值，或者添加一个新的映射关系，

  1.更新/新增一个键/值对,做法是在=号的左侧使用()

 

scala> val map = scala.collection.mutable.Map("a" -> "a", "b" -> "b")
map: scala.collection.mutable.Map[String,String] = Map(b -> b, a -> a)

scala> map("a") = "a1"

scala> map("c") = "c"

scala> print(map("a") + "-" + map("c"))
a1-c

 

  2.添加多个键/值对，使用+=

 

scala> val map = scala.collection.mutable.Map("a" -> "a", "b" -> "b")
map: scala.collection.mutable.Map[String,String] = Map(b -> b, a -> a)

scala> map += ("c" -> "c", "d" -> "d")
res4: map.type = Map(b -> b, d -> d, a -> a, c -> c)

  3.移除某个键和对应的值，使用-=

scala> val map = scala.collection.mutable.Map("a" -> "a", "b" -> "b")
map: scala.collection.mutable.Map[String,String] = Map(b -> b, a -> a)

scala> map -= "b"
res5: map.type = Map(a -> a)

在不可变映射中，你不可以更新其值。但你仍然可以对其进行操作，如

  1.获取一个包含所需要的更新的映射，使用+

scala> val map = Map("a" -> "a", "b" -> "b")
map: scala.collection.immutable.Map[String,String] = Map(a -> a, b -> b)

scala> val newMap = map + ("b" -> "b1", "c" -> "c")
newMap: scala.collection.immutable.Map[String,String] = Map(a -> a, b -> b1, c -> c)

注：newMap映射包含了与map相同的映射关系，此外"c"被添加进来，"b"被更新。在不变映射中，老的和新的映射共享大部分数据结构。

  2.移除不可变映射中某个键，使用-
 

scala> var map = Map("a" -> "a", "b" -> "b")
map: scala.collection.immutable.Map[String,String] = Map(a -> a, b -> b)

scala> map = map + ("b" -> "b1", "c" -> "c")
map: scala.collection.immutable.Map[String,String] = Map(a -> a, b -> b1, c -> c)

scala> map = map - "c"
map: scala.collection.immutable.Map[String,String] = Map(a -> a, b -> b1)

注：不变映射中，老的和新的映射共享大部分数据结构。

---

迭代映射

  如果你想迭代映射，可使用如下结构，即for((k, v) <- 映射) 处理k和v，如

scala> var map = Map("a" -> "a", "b" -> "b")
map: scala.collection.immutable.Map[String,String] = Map(a -> a, b -> b)

scala> for((k, v) <- map) println("key: " + k + ", value: " + v)
key: a, value: a
key: b, value: b

注：如果你想迭代key，则可使用for(k <- map.keySet) ...，如果你想迭代value，则可使用for(v <- map.values) ...，如果你想反转一个映射，则可使用for((k, v) <- 映射) yield (v, k)。

---

与Java的互操作

  如果你通过Java方法调用得到一个Java映射，若你想把它转换为一个Scala映射，你只需增加引用即可，sacla会自动隐式转换为相匹配的映射类型，如，

import scala.collection.JavaConversions.mapAsScalaMap  Map互转

import scala.collection.JavaConversions.propertiesAsScalaMap  Properties与Map互转

---

元组

 

  映射是键/值对偶的集合。对偶是元组(tuple)的最简单形态--元组是不同类型值的聚集。元组的值是通过将单个的值包含在圆括号中构成的。如，(1, 2.66, "lm")是一个元组类型为Tuple3[Int, Double, java.lang.String]的三元数组，元组类型也可写为(Int, Double, java.lang.String)。

 

scala> val tuple = (1, 2.66, "lm")
tuple: (Int, Double, String) = (1,2.66,lm)

 

  1.通过_下标获取元组的值

 

scala> val tuple = (1, 2.66, "lm")
tuple: (Int, Double, String) = (1,2.66,lm)

scala> print(tuple._1)
1

注：你可以使用变量._下标 获取值，也可用变量 _下标获取值。十分注意的是，和数组或字符串中的位置不同，元组的各组元从1开始，而非0。

 

  2.使用匹配模式获取元组的值
 

scala> val tuple = (1, 2.66, "lm")
tuple: (Int, Double, String) = (1,2.66,lm)

scala> val (first, second, thrid) = tuple
first: Int = 1
second: Double = 2.66
thrid: String = lm

注：如果并不是所有的元素都需要，那么你可以在不需要的元素位置上使用_，如val(first, second, _)，则下标为3的值不会被返回。元组可用于函数需要返回不止一个值的情况。

---

拉链操作

  拉链操作，即把多个值绑定在一起，以便他们能够被一起处理，这可以使用zip方法来完成，如

scala> val arr1 = Array("<", "-", ">")
arr1: Array[String] = Array(<, -, >)

scala> val arr2 = Array(2, 10, 2)
arr2: Array[Int] = Array(2, 10, 2)

scala> val pairs = arr1.zip(arr2)
pairs: Array[(String, Int)] = Array((<,2), (-,10), (>,2))

scala> for((s, n) <- pairs) print(s * n)
<<---------->>

注：可以使用toMap方法将对偶转换成映射，即arr1.zip(arr2).toMap。