1、Scala数据结构Map

本文介绍Scala中的Map数据结构。

1、基本知识

Map是健值对映射集合，key要求是唯一的。

Map中数据是无序的。

Map有两种形式：可变的（mutable）、不可变的（immutable）。

不可变结构的Map对象一经实例化后不可修改数据结构，Scala默认使用的是 不可变的Map。

如果要使用可变的Map，需要导入包

import scala.collection.mutable.Map

2、Map的定义方法

（1）定义一个不可变的Map

//in scala 默认的就是不可变类型的Map
val thisIsaMap = Map[(String,String,Int),Seq[Int]](
      ("2020-05-01","2021-05-01",798) -> Seq(7888,20710,2505,5565,18374),
      ("2020-05-01","2021-05-01",870) -> Seq(7817,12380,7420,3659,8516),
      ("2021-04-10","2021-04-30",880) -> Seq(162528,2505,12380,20918,7817)
      )

（2）定义一个可变的Map

//in scala 可变类型的Map需要导入包说明它是可变类型的
val userTypeMap = scala.collection.mutable.Map[(Int,Int,Int), Long]()

3、Map基本操作

Map上的基本操作方法有：

keys: 将Map中的key返回到一个可迭代的数据结构中（既然可迭代，则可使用迭代器.iterator的 .next ,.hasNext() 方法，见本博文6、遍历Map的方法 和 另一篇博文 7、Scala迭代器Iterator）

values： 将Map中的value返回到一个可迭代的数据结构中

isEmpty：如果Map是空的，返回true，否则返回false

val student = Map(12 -> "Reena", 13 -> "Micheal" , 14 -> "Peter")
student.isEmpty
student.keys
student.values

//in scala
object MapOperations {
  def main(args: Array[String]) {
    val student = Map(12 -> "Reena", 13 -> "Micheal", 14 -> "Peter")

    val marks: Map[String, Int] = Map()

    println("Keys : " + student.keys)
    println("Values : " + student.values)
    println("Check if student is empty : " + student.isEmpty)
    println("Check if marks is empty : " + marks.isEmpty)
  }
}

MapOperations.main(null)

4、将两个或更多个Map拼接起来

++ 操作符 或者 Map.++()操作符用来拼接两个或更多个Map，但注意如果被拼接的Map有重复的key，后面Map的key值会覆盖前面key的值。

object ConcatMaps {
   def main(args: Array[String]) {
 	val stud1 = Map(12 -> "Reena", 13 -> "Micheal" , 14 -> "Peter", 15->"Toby")
  	val stud2 = Map(15 -> "Russel", 16 -> "Mark" , 17 -> "Steve")
	 
  	var student = stud1 ++ stud2
  	println( "stud1 ++ stud2 : " + student )

  	val stu = stud1.++(stud2)
  	println( "stud1.++(stud2)) : " + stu )

   }
}

//注意Map中相同key=15的值在拼接前后的变化

5、Map删除一些key和其对应的value

- 操作符用来实现从Map中删除一个或一系列的key

//in scala
val stud1 = Map(12 -> "Reena", 13 -> "Micheal" , 14 -> "Peter")
//删除一个key=12
stud1 - 12
//删掉2个 key=12, key=13
 stud1 - 12 -13
//删掉一系列 key
stud1 - (12,13,14)

6、遍历Map中key、value的方法

6.1 方法一： for循环

// in scala
for(k <- aMap.keys){
        println(k)
        println(aMap(k))
        val startDate:String = k._1
        val endDate:String = k._2
}

//in scala

for ( (k,v) <- aMap ){
        println(k)
        println(v)
}

6.2 方法二：foreach

（i）foreach对Map.keys进行遍历

//in scala
object KeyValues {
   def main(args: Array[String]) {
  	val stud2 = Map(15 -> "Russel", 16 -> "Mark" , 17 -> "Steve")
  	stud2.keys.foreach{ i =>  
                       	print( "Key = " + i )
                       	println(" Value = " + stud2(i) )}
   }
}

(ii) foreach直接对Map进行遍历

object Student {
  def main(args: Array[String]) {
    val stud1 = Map(15 -> "Russel", 16 -> "Mark" , 17 -> "Steve",18 ->"Toby")

    stud1.foreach(x=>{   //循环map里的所有元素; x是(key,value)
      print(s"${x._1},${x._2}------------")
      println(x)
    })
  }
}

6.3 方法三：iterator迭代器

//in scala
object Student {
  def main(args: Array[String]) {
    val stud2 = Map(15 -> "Russel", 16 -> "Mark" , 17 -> "Steve")
    val keySet = stud2.keys
    val key_iter = keySet.iterator  //Map.keys是一个可迭代对象，所以可用.iterator迭代器的hasNext/next方法
    while (key_iter.hasNext){
      val key = key_iter.next
      println(key + ":" + stud2.get(key).get + ":" +stud2.get(key)) //注意get(key)后加不加.get的输出结果区别
    }
  }
}

7、判断Map中有没有指定的key

7.1 map.contains()方法用来判断一个key是不是在Map中

//in scala
object Keyexists {
   def main(args: Array[String]) {
  	val stud2 = Map(15 -> "Russel", 16 -> "Mark" , 17 -> "Steve")
  	if( stud2.contains( 15 )){
       	println("Student Id 15 exists with value :"  + stud2(15))
  	}else{
       	println("Student Id with 15 does not exist")
  	}
  	if( stud2.contains( 18 )){
       	println("Student Id 18  exists with value :"  + stud2(18))
  	}else{
       	println("Student Id 18 does not exist")
  	}
   }
}

7.2 查看Map中是否存在满足某个条件的key。方法  .exists() \ .find()

object Student {
  def main(args: Array[String]) {
    val stud1 = Map(15 -> "Russel", 16 -> "Mark" , 17 -> "Steve",18 ->"Toby")

    println(stud1.contains(15)) //是否包含某个key

    println(stud1.exists(x => { //判断集合中指定条件的元素是否存在; x是(key,value)
      x._1.equals(15)
    }))
    println(stud1.exists(x => { //判断集合中指定条件的元素是否存在; x是(key,value)
      x._2.equals("Toby")
    }))
    
    println(stud1.find(x=>{  //find查找集合中满足指定条件的第一个元素; x是(key,value)
      x._1.toString.equals(x._2)
    }))
 }
}

8、给可变类型Map中的key赋值

使用 Map.getOrElse(key,默认值)方法，如果key在Map中存在，则获取其value，否则返回一个默认值

//给可变类型的Map中追加数据 或者修改已有key的值，使用 .getOrElse() 的方法做到

if (userTypeCode.contains(userType)) {
     userTypeMap((taCode,windowType,userType)) =
         userTypeMap.getOrElse((taCode,windowType,userType), 0L) + 1L
     }

9、查看Map中最大、最小元素

Map.max , Map.min 函数实现查看Map中最大、最小元素

//in scala
val stud1 = Map(12 -> "Reena", 13 -> "Micheal" , 14 -> "Peter")
stud1.max
stud1.min

10、过滤Map中满足条件的元素，Map.filter()方法。返回的结果还是Map数据结构。

object Student {
  def main(args: Array[String]) {
    val stud1 = Map(15 -> "Russel", 16 -> "Mark" , 17 -> "Steve",18 ->"Toby")
    val stud2 = Map(15 -> "Russel", 16 -> "Mark" , 17 -> "Steve",18 ->"Mark")
    
    println(stud1.filter(x=>{  //返回满足指定条件的所有集合; x是(key,value)
      x._2.length > 4
    }))
    println(stud1.filter(x=>{  //返回满足指定条件的所有集合; x是(key,value)
      x._1 > 16
    }))
    println(stud1.filterKeys(x=>{ //filterKeys返回符合指定条件的不可变Map; x就是key
      x.equals(16)
    }))
  }
}

11、按照规则对Map中满足条件的元素进行统计计数

object Student {
  def main(args: Array[String]) {
    val stud2 = Map(15 -> "Russel", 16 -> "Mark" , 17 -> "Steve",18 ->"Mark")

    val age_count = stud2.count(x=>{  //计算满足指定条件的集合元素数量; x是(key,value)
      x._2.equals("Mark")
    })
    println(age_count)

  }
}

12、其他函数或方法

12.1 博客 scala之map操作史上最全

12.2 判断两个Map是否相同 .equals()

object Student {
  def main(args: Array[String]) {
    val stud1 = Map(15 -> "Russel", 16 -> "Mark" , 17 -> "Steve",18 ->"Toby")
    val stud2 = Map(15 -> "Russel", 16 -> "Mark" , 17 -> "Steve",18 ->"Mark")

    println(stud1.equals(stud2)) //如果两个 Map 相等(key/value 均相等)，返回true，否则返回false;
    }
}