Scala中map和Java类似,也是一个散列表,它存储的内容也是键值对(Key-Value映射),Scala中不可变的Map是有序的,可变的Map是无序的

可变的Map (Scala.collection.mutable.Map) 和不可变的Map(Scala.collection.immutable.Map)

默认导入的是不可变的Map,构建Map中元素的底层是Tuple2类型

1
2
3
4
5
6
7
8
9
10
object MapDemo {
  def main(args: Array[String]): Unit = {
    // 1. 默认的map是 immutable.Map不可变的
    // 2. key  value 支持any类型
    // 3. map 底层 每对 key value是tuple元组类型
    val map = Map("alice" -> 10, "Bob" -> 12, "kotlin" -> 21)
    //    构建不可变的Map
    val map02 = mutable.Map("a" -> "b", "c" -> "d")
  }
}

创建空的Map

1
2
3
//    创建空的Map映射
    val nullMap = mutable.Map()
    println(nullMap)

对偶元组

即创建包含键值对的二元组,和第一种方式等价,只是形式上不同而已。对偶元组就是只含有两个数据的元组

1
2
3
//    声明对偶元组
    val tuple = mutable.Map(("alice", 10), ("Bob", 23), ("kotlin", 19))
    println(tuple)

映射Map取值

方式一 使用map(key)

  1. 如果key存在,则返回对应的值
  2. 如果key不存在,则抛出异常 [java.util.NoSuchElementException]
  3. 在Java中如果key不存在则返回null
1
2
3
4
5
6
//    map的取值
    //    如果key存在,则返回对应的值
    //    如果key不存在,则抛出异常 [java.util.NoSuchElementException]
    //    在Java中如果key不存在则返回null
    val i = tuple("alice")
    println(i)

方式二 首先使用contains方法来判断key是否存在,存在的话我们再进行取值

1
2
3
4
5
6
7
8
9
10
11
if (tuple.contains("alice")) {
      println(tuple("alice"))
    } else {
      println("key不存在")
    }
    println("============")
    if (tuple.contains("alice~~")) {
      println(tuple.contains("alice"))
    } else {
      println("key不存在")
    }

方式三 使用map.get(key).get取值

  1. 如果key存在 map.get(key)就会返回some(值),然后再使用 some.get()就会获取到值
  2. 如果key不存在 map.get(key)就会返回None(注意是这个None不是Null)
1
2
3
4
5
6
7
8
9
if (tuple.get("alice") != null) {
      println(tuple.get("alice").get)
    }
    println("===============")
    if (tuple.get("alice~") != None) {
      println(tuple.get("alice").get)
    } else {
      println("key不存在")
    }

方式四 使用 map.getOrElse()取值

  1. 如果Key存在,返回Key对应的值
  2. 如果key不存在,返回默认值。在Java底层有很多类似的操作
1
2
3
4
// 方法四
    println("方法四========================")
    println(tuple.getOrElse("alice", "默认值 <。)#)))≦   🐟"))
    println(tuple.getOrElse("alice~", "默认值 <。)#)))≦   🐟"))

Map的值操作

更新map的值 map(key)= 值

  1. 当map是可变的时候,才能修改,否则报错
  2. 如果key存在:则修改对应的值,如果key不存在,则相当于添加一个key→value的值
1
2
3
4
//更新map的值
println("更新map的值============")
tuple("alice") = 123
println(tuple.get("alice").get)

使用 += 增加单个元素

1
2
3
4
//        更新map的值
  println("使用(+=)============")
  tuple += ("富贵" -> 123)
  println(tuple("富贵"))

增加多个元素

1
2
3
4
5
//    增加多个元素
    //    方式一:通过声明一个新的 map集合来拼接另一个map集合
    val tuple2 = tuple + ("张三" -> 12, "李四" -> 10)
    //    方式二:通过+= 来添加多个
    tuple += (("王五" -> 12), ("赵六" -> 57))、

添加元素时：如果增加的Key已经存在会怎么样

它会直接把值给更新了

map删除元素

  1. 根据Key删除,可以写多个
  2. 如果Key存在,就删除,如果Key不存在,也不会报错
1
2
3
4
// 删除key
  println("删除key============")
  tuple -= ("富贵", "李四")
  println(tuple)

Map的遍历

map遍历的方式有很多,有四种方式具体如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
//    map的遍历
    //    方式一
    println("方式一===============")
    for ((k, v) <- tuple) {
      println("key的值为:" + k)
      println("value的值为:" + v)
    }
    //    方式二
    println("方式二===============")
    for (k <- tuple.keys) {
      println("key的值为:" + k)
      println("value的值为" + tuple(k))
    }
    //    方式三
    println("方式一===============")
    for (v <- tuple.values) {
      println("value的值为" + v)
    }
    //    方式四
    println("方式四===============")
    for (t <- tuple) {
      println("key的值为:" + t._1)
      println("value的值为:" + t._2)
    }
    println("方式五===============")
    //    通过keySet来取值
    val tupleSet = tuple.keySet
    for (keys <- tupleSet) {
      println("value的值为:" + tuple(keys))
    }
    println("方式六===============")
    val tupleSet2 = tuple.keySet
    val iterator = tupleSet2.iterator

    while (iterator.hasNext) {
      println("value的值为" + tuple(iterator.next()))
    }