scala的多种集合的使用(6)之映射Map的操作方法

1.创建映射

1)创建不可变的映射

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

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

2)创建可变的映射，要么用导入的方式将其带入作用域中，要么就在创建实例时指定scala.collection.mutable.Map类的完整路径。

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

3)在创建的时候创建一空可变的Map，之后在添加元素。

scala> var status = collection.mutable.Map[Int,String]()
status: scala.collection.mutable.Map[Int,String] = Map()

scala> status += ((1,"a"))
res38: scala.collection.mutable.Map[Int,String] = Map(1 -> a)

scala> status += ((3,"c"),(2,"b"))
res39: scala.collection.mutable.Map[Int,String] = Map(2 -> b, 1 -> a, 3 -> c)

2.Map使用的场景

1)想要返回元素按照键有序的映射，请使用SortedMap。

scala> import scala.collection.SortedMap
import scala.collection.SortedMap

scala> val grades = SortedMap(("kim",90),("al",86),("mes",88),("ema",78),("han",93))
grades: scala.collection.SortedMap[String,Int] = Map(al -> 86, ema -> 78, han ->93, kim -> 90, mes -> 88)

scala> val grades = SortedMap((1,90),(3,86),(2,88),(5,78),(4,93))
grades: scala.collection.SortedMap[Int,Int] = Map(1 -> 90, 2 -> 88, 3 -> 86, 4 -> 93, 5 -> 78)

2)按插入时的顺序返回元素，只有可变的LinkedHashMap。

scala> import scala.collection.mutable.LinkedHashMap
import scala.collection.mutable.LinkedHashMap

scala> var status = LinkedHashMap((5,"apple"))
status: scala.collection.mutable.LinkedHashMap[Int,String] = Map(5 -> apple)

scala> status += ((3,"orange"))
res40: scala.collection.mutable.LinkedHashMap[Int,String] = Map(5 -> apple, 3 -> orange)

scala> status += ((6,"banana"))
res41: scala.collection.mutable.LinkedHashMap[Int,String] = Map(5 -> apple, 3 ->orange, 6 -> banana)

3)按插入时的相反顺序返回元素，可以是可变的或者不可变的ListMap。

scala> import scala.collection.mutable.ListMap
import scala.collection.mutable.ListMap

scala> var status = ListMap((1,"a"))
status: scala.collection.mutable.ListMap[Int,String] = Map(1 -> a)

scala> status += ((1,"a"))
res43: scala.collection.mutable.ListMap[Int,String] = Map(1 -> a)

scala> status += ((2,"b"))
res44: scala.collection.mutable.ListMap[Int,String] = Map(2 -> b, 1 -> a)

scala> status += ((3,"c"))
res45: scala.collection.mutable.ListMap[Int,String] = Map(3 -> c, 1 -> a, 2 -> b)

3.可变映射的添加、更新和删除元素

1)通过给键指定值的方式为可变映射添加元素。

scala> var status = scala.collection.mutable.Map[String,String]()
status: scala.collection.mutable.Map[String,String] = Map()

scala> status("a1") = "a1a"

scala> status
res47: scala.collection.mutable.Map[String,String] = Map(a1 -> a1a)

2)通过+=方法添加一个或者多个元素。

scala> var status = scala.collection.mutable.Map[String,String]()
status: scala.collection.mutable.Map[String,String] = Map()

scala> status += (("a1","a1a"))
res50: status.type = Map(a1 -> a1a)

scala> status
res51: scala.collection.mutable.Map[String,String] = Map(a1 -> a1a)

scala> status += (("a1","a1a"),("a2","a2a"))
res52: status.type = Map(a1 -> a1a, a2 -> a2a)

scala> status
res53: scala.collection.mutable.Map[String,String] = Map(a1 -> a1a, a2 -> a2a)

3)用++=从另一个集合添加多个元素。

scala> var status = scala.collection.mutable.Map[String,String]()
status: scala.collection.mutable.Map[String,String] = Map()

scala> status ++= List(("a1","a1a"),("a2","a2a"))
res55: status.type = Map(a1 -> a1a, a2 -> a2a)

4)用-=的方法通过指定元素的键从映射中删除一个或者多个元素。

scala> status ++= List(("a1","a1a"),("a2","a2a"))
res56: status.type = Map(a1 -> a1a, a2 -> a2a)

scala> status -= "a1"
res57: status.type = Map(a2 -> a2a)

scala> status
res58: scala.collection.mutable.Map[String,String] = Map(a2 -> a2a)

scala> status -= ("a1","a2")
res60: status.type = Map()

scala> status
res61: scala.collection.mutable.Map[String,String] = Map()

5)用--=删除集合里的指定的元素。

scala> var status = scala.collection.mutable.Map[String,String]()
status: scala.collection.mutable.Map[String,String] = Map()

scala> status ++= List(("a1","a1a"),("a2","a2a"))
res67: status.type = Map(a1 -> a1a, a2 -> a2a)

scala> status --= List("a1","a2")
res68: status.type = Map()

scala> status
res69: scala.collection.mutable.Map[String,String] = Map()

6)通过赋值值给元素的键更新元素。

scala> var status = scala.collection.mutable.Map[String,String]()
status: scala.collection.mutable.Map[String,String] = Map()

scala> status ++= List(("a1","a1a"),("a2","a2a"))
res72: status.type = Map(a1 -> a1a, a2 -> a2a)

scala> status("a1") = "hello world"

scala> status
res74: scala.collection.mutable.Map[String,String] = Map(a1 -> hello world, a2 -> a2a)

4.不可变映射的添加、更新和删除元素

1)用+个方法添加一个或者多个元素，在这个过程中将结果赋给一个新的变量。

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

scala> val b = a + (("a2","a2a"))
b: scala.collection.immutable.Map[String,String] = Map(a1 -> a1a, a2 -> a2a)

scala> val c = b + (("a3","a31"),("a4","a4a"))
c: scala.collection.immutable.Map[String,String] = Map(a1 -> a1a, a2 -> a2a, a3 -> a31, a4 -> a4a)

2)更新一个不可变映射的键值对，需要用+方法对键/值重新赋值，新值替换旧值。

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

scala> val b = a + (("a2","a2a"))
b: scala.collection.immutable.Map[String,String] = Map(a1 -> a1a, a2 -> a2a)

scala> val c = b + (("a1","hello world"))
c: scala.collection.immutable.Map[String,String] = Map(a1 -> hello world, a2 -> a2a)

3)使用-方法删除一个或者多个元素。

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

scala> val b = a + (("a2","a2a"),("a3","a3a"),("a4","a4a"))
b: scala.collection.immutable.Map[String,String] = Map(a1 -> a1a, a2 -> a2a, a3
-> a3a, a4 -> a4a)

scala> val c = b - "a1" - "a2"
c: scala.collection.immutable.Map[String,String] = Map(a3 -> a3a, a4 -> a4a)

scala> val d = c - "a4"
d: scala.collection.immutable.Map[String,String] = Map(a3 -> a3a)

当一个不可变的变量声明为var时，它仍然是一个不可变的映射，不能给映射中的元素重新赋值。

5.映射值的访问

1)访问保存在映射中单独的值，如果键不存在，会抛出异常。为了避免这个问题，可以在创建映射时使用withDefaultValue的方法。该方法会创建一个默认值，如果键没有找到，映射会返回这个值。

scala> val status = Map((1,"a"),(2,"b"),(3,"c")).withDefaultValue("Not Found")
status: scala.collection.immutable.Map[Int,String] = Map(1 -> a, 2 -> b, 3 -> c)

scala> status(4)
res5: String = Not Found

scala> status(3)
res6: String = c

2)寻找键时可以使用getOrElse方法，当指定的键找不到时，会返回默认值。

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

scala> val s = status.getOrElse(6,"Not such value")
s: String = Not such value

3)可以使用get方法返回Option对象。

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

scala> val s = status.get(5)
s: Option[String] = None

scala> val s = status.get(2)
s: Option[String] = Some(b)

6.映射的遍历

1)for循环遍历所有的映射元素。

scala> val status = Map((1,"a"),(2,"b"),(3,"c"),(4,"d"))
status: scala.collection.immutable.Map[Int,String] = Map(1 -> a, 2 -> b, 3 -> c, 4 -> d)

scala> for((k,v) <- status) println(s"key: $k, value: $v")
key: 1, value: a
key: 2, value: b
key: 3, value: c
key: 4, value: d

2)匹配表达式配合foreach方法。

scala> val status = Map((1,"a"),(2,"b"),(3,"c"),(4,"d"))
status: scala.collection.immutable.Map[Int,String] = Map(1 -> a, 2 -> b, 3 -> c, 4 -> d)

scala> status.foreach{
	 | case(k,v) => println(s"key: $k,value: $v")
	 | }
key: 1,value: a
key: 2,value: b
key: 3,value: c
key: 4,value: d

3)使用Tuple语法访问键/值字段。

scala> val status = Map((1,"a"),(2,"b"),(3,"c"),(4,"d"))
status: scala.collection.immutable.Map[Int,String] = Map(1 -> a, 2 -> b, 3 -> c, 4 -> d)

scala> status.foreach(x => println(s"key: ${x._1},value: ${x._2}"))
key: 1,value: a
key: 2,value: b
key: 3,value: c
key: 4,value: d

4)如果想要映射中所有的键，keys方法返回Iterable。

scala> val status = Map((1,"a"),(2,"b"),(3,"c"),(4,"d"))
status: scala.collection.immutable.Map[Int,String] = Map(1 -> a, 2 -> b, 3 -> c, 4 -> d)

scala> status.keys.foreach((key) => println(key))
1
2
3
4

5)如果想要映射中所有的value的值，用values方法可以遍历映射中所有的值。

scala> val status = Map((1,"a"),(2,"b"),(3,"c"),(4,"d"))
status: scala.collection.immutable.Map[Int,String] = Map(1 -> a, 2 -> b, 3 -> c, 4 -> d)

scala> status.values.foreach((value) => println(value))
a
b
c
d

7.操作映射的值

1)如果要遍历映射并对每个值进行操作，mapValues是个不错的选择。它可以在每个映射值上执行一个函数，然后返回修改后的映射。

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

scala> val y = x.mapValues(_.toUpperCase)
y: scala.collection.Map[Int,String] = Map(2 -> B, 1 -> A)

2)transform方法可以同时使用键/值实现一个变换方法。

scala> val map = Map((1,10),(2,20),(3,30))
map: scala.collection.immutable.Map[Int,Int] = Map(1 -> 10, 2 -> 20, 3 -> 30)

scala> val newMap = map.transform((k,v) => k + v)
newMap: scala.collection.immutable.Map[Int,Int] = Map(1 -> 11, 2 -> 22, 3 -> 33)

8.从映射中获取所有的键和值

1)用keySet的方法将以集合的方式获取所有的键。

scala> val status = Map(("a1","a1a"),("a2","a2a"),("a3","a3a"))
status: scala.collection.immutable.Map[String,String] = Map(a1 -> a1a, a2 -> a2a, a3 -> a3a)

scala> status.keySet
res14: scala.collection.immutable.Set[String] = Set(a1, a2, a3)

2)用keys方法获得一个Iterable。

scala> status.keys
res16: Iterable[String] = Set(a1, a2, a3)

3)用keysIterator方法获取所有作为迭代器的键。

scala> status.keysIterator
res17: Iterator[String] = non-empty iterator

4)使用values方法可以获取映射中所有的值，并将结果转化为Iterable对象。

scala> status.values
res18: Iterable[String] = MapLike(a1a, a2a, a3a)

5)使用valuesIterator方法，返回Iterator对象。

scala> status.valuesIterator
res19: Iterator[String] = non-empty iterator

keysIterator和valuesIterator方法都会从映射数据返回一个迭代器。这些方法不会创建一个新的集合，仅仅是提供遍历已存在的迭代器。

9.反转键值

可以用for推导反转映射的键值，然后将结果赋给一个新的变量。但是映射中，key是不重复的，value是可以重复的，但是在反转时可能会丢掉数据。

scala> val status = Map(("a1","a1a"),("a2","a2a"),("a3","a3a"))
status: scala.collection.immutable.Map[String,String] = Map(a1 -> a1a, a2 -> a2a, a3 -> a3a)

scala> val newMap = for((k,v) <- status) yield (v,k)
newMap: scala.collection.immutable.Map[String,String] = Map(a1a -> a1, a2a -> a2, a3a -> a3)

10.测试映射中键/值的存在

1)用contains方法测试映射中是否包含键。

scala> val status = Map(("a1","a1a"),("a2","a2a"),("a3","a3a"))
status: scala.collection.immutable.Map[String,String] = Map(a1 -> a1a, a2 -> a2a, a3 -> a3a)

scala> if (status.contains("a1")) println("found a1") else println("not found")
found a1

scala> if (status.contains("a5")) println("found a5") else println("not found")
not found

2)使用valuesIterator方法搜索值，结合exists和contains。

scala> val status = Map(("a1","a1a"),("a2","a2a"),("a3","a3a"))
status: scala.collection.immutable.Map[String,String] = Map(a1 -> a1a, a2 -> a2a, a3 -> a3a)

scala> status.valuesIterator.exists(_.contains("a2a"))
res22: Boolean = true

scala> status.valuesIterator.exists(_.contains("a2a2"))
res23: Boolean = false

11.根据键或者值对映射排序

1)可以用sortBy方法对值(_2)/键(_1)从低到高进对映射进行排序。

scala> val grade = Map((1,98),(2,89),(3,88),(4,93),(5,95))
grade: scala.collection.immutable.Map[Int,Int] = Map(5 -> 95, 1 -> 98, 2 -> 89, 3 -> 88, 4 -> 93)

scala> import scala.collection.immutable.ListMap
import scala.collection.immutable.ListMap

scala> ListMap(grade.toSeq.sortBy(_._2):_*)
res25: scala.collection.immutable.ListMap[Int,Int] = Map(3 -> 88, 2 -> 89, 4 -> 93, 5 -> 95, 1 -> 98)

2)可以用sortWith方法对值(_2)/键(_1)按照升序或者降序对值进行排序。

//按照值升序:
scala> ListMap(grade.toSeq.sortWith(_._2 < _._2):_*)
res28: scala.collection.immutable.ListMap[Int,Int] = Map(3 -> 88, 2 -> 89, 4 ->93, 5 -> 95, 1 -> 98)
//按照值降序:
scala> ListMap(grade.toSeq.sortWith(_._2 > _._2):_*)
res29: scala.collection.immutable.ListMap[Int,Int] = Map(1 -> 98, 5 -> 95, 4 ->93, 2 -> 89, 3 -> 88)

关于_*:
它的作用是将数据转换，然后将其作为多个参数传给ListMap。

12.映射中键值的最值

1)对键进行排序。

scala> val grade = Map((1,98),(2,89),(3,88),(4,93),(5,95))
grade: scala.collection.immutable.Map[Int,Int] = Map(5 -> 95, 1 -> 98, 2 -3 -> 88, 4 -> 93)

scala> grade.max
res31: (Int, Int) = (5,95)

scala> grade.keysIterator.max
res32: Int = 5

scala> grade.keysIterator.reduceLeft((x,y) => if(x > y) x else y)
res33: Int = 5

2)对值进行排序 。

scala> val grade = Map((1,98),(2,89),(3,88),(4,93),(5,95))
grade: scala.collection.immutable.Map[Int,Int] = Map(5 -> 95, 1 -> 98, 2 -> 89,3 -> 88, 4 -> 93)

scala> grade.valuesIterator.max
res40: Int = 98

scala> grade.valuesIterator.reduceLeft((x,y) => if(x > y) x else y)
res41: Int = 98

scala> grade.valuesIterator.reduceLeft(_ max _)
res42: Int = 98

原文地址：https://www.cnblogs.com/zhaohadoopone/p/9534242.html

时间： 2024-10-10 20:51:38

scala的多种集合的使用(6)之映射Map的操作方法的相关文章

scala的多种集合的使用(7)之集Set的操作方法

1.给集添加元素 1)用+=.++=和add给可变集添加元素. scala> var set = scala.collection.mutable.Set[Int]() set: scala.collection.mutable.Set[Int] = Set() scala> set += 1 res48: scala.collection.mutable.Set[Int] = Set(1) scala> set += (2,3) res49: scala.collection.muta

spring心得4--setter注入集合(set、list、map、properties等多种集合，配有案例解析)@基本装(引用)

spring心得4--setter注入集合(set.list.map.properties等多种集合,配有案例解析)@基本装 1. 基本装配 在spring容器内拼凑bean叫做装配.装配bean的时候,需要告诉容器哪些bean以及容器如何使用依赖注入将它们配合在一起.    使用XML装配(xml是最常见的spring应用系统配置源.) 几种spring容器都支持使用xml装配bean,包括: 1).XmlBeanFactory:调用InputStream载入上下文定义文件. 2).Class

11. Scala数据结构(下)-集合操作

11.1 集合元素的映射-map映射操作 11.1.1 看一个实际需求 要求:请将List(3,5,8)中所有的元素都*2,将其结果放到一个新的集合中返回,即返回一个新的List(6,10,16),请编写程序实现 11.1.2 map映射操作    11.1.3 使用传统方法 -案例演示 object boke_demo01 { def main(args: Array[String]): Unit = { /* 请将List(3,5,8) 中的所有元素都 * 2 , 将其结果放到一个新的集合中

好程序员大数据学习路线分享Scala系列之集合操作函数

好程序员大数据学习路线继续为大家分享Scala系列之集合操作函数4.6 集合的重要函数4.6.1sum/max/min/count在序列中查找最大或最小值是一个极常见的需求,如下:val numbers = Seq(11, 2, 5, 1, 6, 3, 9) numbers.max //11 numbers.min //1 更高级的例子,其中包含一个书的序列case class Book(title: String, pages: Int) val books = Seq( Book("Futu

Java基础——集合（二）——迭代器、Map集合

接上篇,<Java基础--集合(一)--集合体系和Collection> 四．迭代器的使用 使用步骤: 1.通过集合对象获取迭代器对象. 2.通过迭代器对象判断. 3.通过迭代器对象获取. 迭代器原理 由于多种集合的数据结构不同,所以存储方式不同,所以,取出方式也不同. 这个时候,我们就把判断和获取功能定义在了一个接口中,将来,遍历哪种集合的时候,只要该集合内部实现这个接口即可. 迭代器源码 public interface Iterator { publicabstract boolean

从零学scala（二）数组相关操作、映射和元组

一:数组相关操作 定长数组 val array = Array[String]("a","b","c") //直接初始化数组的内容        println(array.mkString("|")) val array = new Array[String](2) //new一个长度为2的数据在通过更新的方法进行赋值        array.update(0, "0")        array.up

Java集合框架总结（5）——Map接口的使用

Java集合框架总结(5)--Map接口的使用 Map用于保存具有映射关系的数据(key-vlaue).Map的key不允许重复,即同一个Map对象的任何两个key通过equals方法比较总是返回false Map中包含了一个keySet()方法,用于返回Map所以key组成的Set集合. Map集合与Set集合元素的存储形式很像,如Set接口下有HashSet.LinkedHashSet.SortedSet(接口).TreeSet.EnumSet等实现类和子接口,而Map接口下则有HashMa

编程算法 - 二叉搜索树(binary search tree) 集合(set)和映射(map) 代码(C)

二叉搜索树(binary search tree) 集合(set)和映射(map) 代码(C++) 本文地址: http://blog.csdn.net/caroline_wendy 二叉搜索树(binary search tree)作为常用而高效的数据结构, 标准库中包含实现, 在标准库的集合(set)和映射(map), 均使用. 具体操作代码如下. 代码: /* * main.cpp * * Created on: 2014.7.20 * Author: spike */ /*eclipse

Java 中的集合接口——List、Set、Map

Java 中的集合接口——List.Set.Map 什么叫集合:集合就是Java API所提供的一系列类的实例,可以用于动态存放多个对象.这跟我们学过的数组差不多,那为什么我们还要学集合,我们看看数组跟集合有什么区别: 数组:长度固定,遍历速度快 可以存储基本类型和引用类型: 集合:长度不固定,只能存储引用类型对象: 从数组跟集合的特点我们很明显的看出,数组有一定的局限性,如果我们需要不定期的往我们的数据中存储数据,数组就满足不了我们的要求. Java集合框架提供了一套性能优良.使用方便的接口和