Scala基础（5）：Map、元组

元组

创建元组

  val a = ("Johnny", 2016, "Yang")
  val b = ("Johnny","Yang") //最简单的元组：对偶

基本操作

  val yzSecond1 = yz._2//取出第二个元素
  val yzSecond2 = yz _2;
  println("第二个值是" + yzSecond1)
  println("第二个值是" + yzSecond2)

  // 使用模式匹配
  val (first, second, _) = yz
  println("first:" + first + "；second:" + second)
  }

元组取值和数组不一样，yz._1表示取出第一个元素

映射

Scala中Map(映射)分为可变映射和不可变映射两种，默认创建不可变映射。

创建映射

    // 构建拥有3个对偶的不可变映射
    val map1 = Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8)

    // 构建空的映射可变映射
    val map2 = new scala.collection.mutable.HashMap[String, Int] //这里指定映射实现为HashMap，类型参数为String和Int

    // 构建拥有3个对偶的可变映射
    val map3 = scala.collection.mutable.Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8)

    // 通过对偶创建映射
    val map4 = Map(("Alice", 10), ("Bob", 3), ("Cindy", 8))

“->” 符号用于创建对偶
“Alice” -> 10 会生成 (“Alice”,10)

基本操作

取值

    val arg1 = m("Bob")
    // Scala直接通过 映射(键) 来获取元素，通过 映射.get(键) 得到的是一个Option对象
    val arg2 = if (m.contains("Bob")) m("Bob") else 0// 如果不存在会抛出异常，因此需要作出检查
    val arg3 = m.getOrElse("Bob", 0)// 同上，但是不会报错，如果没有"Bob"会返回0

更新

  /*更新可变映射*/
    m("Bob") = 10
    m +=("Bob" -> 10, "Fred" -> 15) //有就更新，没有就插入
    m -= "Bob" // 移除
  }

  /*更新不可变映射*/
    val newMap = m + ("Bob" -> 10, "Fred" -> 16)
    // 更新不可变映射会创建新的映射，newMap 包含 m 相同映射关系，然后Bob被更新，Fred被添加进来

遍历

  /*遍历映射*/
    for ((k, v) <- m) println("k:" + k + ";v:" + v)

    for ((k, v) <- m) yield (v, k)//返回一个集合，键值反转

  /*遍历映射的键*/
    for (k <- m.keySet) print("k:" + k)

  /*遍历映射的值*/
    for (v <- m.values) print("v:" + v)

拉链操作

    // 拉链操作
    val symbols = Array("<", "-", ">")
    val counts = Array(2, 10, 2)
    val pairs = symbols.zip(counts) // 输出对偶的数组 Array(("<",2),("-",10),(">",2))
    for ((s, n) <- pairs) Console.print(s * n) // 输出：<<-------->>
    val m = pairs.toMap // 转化成映射
    mapIterate(m)//遍历

拉链操作步骤：

1. 创建两个数组，arrA用于存放键，arrB用于存放值
2. 使用arrA.zip(arrB)来生成一个新的对偶数组arrC
3. 使用数组的toMap方法将对偶数组转化成映射

需要注意的：

scala.collection.mutable 和 scala.collection.immutable 中HashMap和Map的区别

package yangjun.myPackage

import yangjun.myClass.Person

import scala.collection.mutable //可变的
import scala.collection.immutable //不可变的

/**
  * Created by Yang Jun on 2016/7/23.
  */
object Test {
  def main(args: Array[String]): Unit = {
    demo001
    demo002
    demo003
    demo004
  }

  def demo001(): Unit = {
    // 变量 + 可变
    var rmm = mutable.Map("a" -> 1, "b" -> 2)
    //rmm += ("c" -> 3)//+=操作成功
    var rmh = mutable.HashMap("a" -> 1, "b" -> 2)
    //rmh += ("c" -> 3)//+=操作成功

  }

  def demo002(): Unit = {
    // 变量 + 不可变
    var rim = immutable.Map("a" -> 1, "b" -> 2)
    //rim += ("c" -> 3)//+=操作成功
    var rih = immutable.HashMap("a" -> 1, "b" -> 2)
    //rih += ("c" -> 3)//+=操作成功

    // 首先返回的是一个新的映射，然后变量重新指向

  }

  def demo003(): Unit = {
    // 常量 + 可变
    val lmm = mutable.Map("a" -> 1, "b" -> 2)
    //lmm += ("c" -> 3) //+=操作成功
    val lmh = mutable.HashMap("a" -> 1, "b" -> 2)
    //lmh += ("c" -> 3) //+=操作成功

    // mutable.Map 和 mutable.HashMap 有 += 函数
  }


  def demo004(): Unit = {
    // 常量 + 不可变
    val lim = immutable.Map("a" -> 1, "b" -> 2)
    //lim += ("c" -> 3) //+=操作失败
    val lih = immutable.HashMap("a" -> 1, "b" -> 2)
    //lih += ("c" -> 3) //+=操作失败

    // immutable.Map 和 immutable.HashMap 没有 += 函数
  }

}

详见 http://blog.youkuaiyun.com/shen_jz2012/article/details/50320929