【scala系列】7、容器类型:Map、Scala与Java容器类型转换介绍


1. Map

映射(Map)是一种可迭代的键值对结构(也称映射或关联)。在scala中map分为可变长(mutable)与不可变长(imutable),不可变长map映射初始化之后,其长度与值都不能改变。
Scala的Predef类提供了隐式转换,允许使用另一种语法:key -> value,来代替(key, value)。
如:Map(“x” -> 24, “y” -> 25, “z” -> 26)等同于Map((“x”, 24), (“y”, 25), (“z”, 26)),却更易于阅读。

1.1 Map 初始化

//1.通过对偶元组创建map 映射
val m1 = Map(("a", "A"), ("b", "B"), ("c", "C"))
println(m1) //Map(a -> A, b -> B, c -> C)

//2. 通过 箭头方式创建map映射
val m2 = Map("a" -> "A", "b" -> "B", "c" -> "C")
println(m2) //Map(a -> A, b -> B, c -> C)

// 定义可变长map映射 mutable
import scala.collection.mutable
val m3 = mutable.Map(("a", "A"), ("b", "B"), ("c", "C"))
println(m3) //Map(a -> A, b -> B, c -> C)

val m4 = mutable.Map("a" -> "A", "b" -> "B", "c" -> "C")
println(m4) //Map(a -> A, b -> B, c -> C)

1.2 Map 查看元素


val m1 = Map("a" -> "A", "b" -> "B", "c" -> "C")

//get方法也是用来获取key对应的值,但是这个方法返回的是一个option 对象,这个option对象有两个子类
//如果key存在 则返回some(some对象中封装了key对应的值,可以通过some的get方法获取该值)
//如果key不存在 则返回None对象
println(m1.get("a")) //Some(A)
println(m1.get("a").get) //A

// 使用getOrElse 当没有获取到数据的时候也不会出现空指针异常
println(m1.get("Z").getOrElse("not found"))//not found

//如果获取不存在的key会报错 ,所以当直接通过key获取值得时候需要先判断key是否存在
println(m1("b")) //B

println(m1.max) //(c,C)
println(m1.min) //(a,A)

// 判断是否存在某个key,存在true  不存在false
println(m1.contains("z")) //false
println(m1.contains("a")) //true

println(m1.values) //MapLike(A, B, C)
println(m1.keys) //Set(a, b, c)

1.3 Map 增加元素

 val m1 = mutable.Map(("a", "A"),("b", "B"))
val m2 = mutable.Map(("b", "B"),("c", "C"))

//++ 运算符将连个map映射进行合并,并没有改变原有map映射的值
//重复的key 会只取一个值,后面的值会覆盖前面的值
val m3 = m1 ++ m2
println(m3) //Map(b -> B, a -> A, c -> C)

m1.put("c", "C")
println(m1) //Map(b -> B, a -> A, c -> C)

m1 += (("d", "D"))
println(m1) //Map(b -> B, d -> D, a -> A, c -> C)

m1 ++= mutable.Map("e" -> "E")
println(m1) //Map(e -> E, b -> B, d -> D, a -> A, c -> C)

//3. 两者混合创建map映射
val m4 = mutable.Map(("a", "A"), "b" -> "B")
println(m4) //Map(a -> A, b -> B)
m4.getOrElseUpdate("c","C")
println(m4) // Map(b -> B, a -> A, c -> C)

// 想要修改元素直接覆盖即可
m4.put("b","new B")
println(m4) // Map(b -> new B, a -> A, c -> C)

m4.update("c","new C")

println(m4) // Map(b -> new B, a -> A, c -> new C)

1.4 Map 修改元素

val m4 = mutable.Map(("a", "A"), "b" -> "B", "c" -> "C")
// 想要修改元素直接覆盖即可
m4.put("b","new B")
println(m4) // Map(b -> new B, a -> A, c -> C)

m4.update("c","new C")

println(m4) // Map(b -> new B, a -> A, c -> new C)

1.5 Map 删除元素

val m1 = mutable.Map(("a", "A"),("b", "B"),("c", "C"),("d", "D"),("e", "E"),("f", "F"),("g", "G"))

m1 -= "a"
println(m1) //Map(e -> E, b -> B, d -> D, g -> G, c -> C, f -> F)

m1 --= Set("b", "c")
println(m1) //Map(e -> E, d -> D, g -> G, f -> F)

m1.remove("d")
println(m1) //Map(e -> E, g -> G, f -> F)

1.6 SortedMap 元素排序


//SortedMap能够自动对map的key 按照字典顺序排序
val m1 = scala.collection.immutable.SortedMap("Alice" -> 10, "Fred" -> 7, "Bob" -> 3, "Cindy" -> 8)

println(m1) //Map(Alice -> 10, Bob -> 3, Cindy -> 8, Fred -> 7)

1.7 有序Map LinkedHashMap

//linkedHashMap 插入有序,会按照我们插入的顺序排序,底层是链表

 val m1 = mutable.LinkedHashMap[String,String]()

m1 += ("d"->"D")
m1 +=(("e","E"))
m1("f") = "F"

println(m1) //Map(d -> D, e -> E, f -> F)

1.8 多值Map

// 结合Map和Tuple,很容易实现一个key对应的value是组合值的数据结构:

val m1 = Map(1->("james",20), 2->("qh",30), 3->("qiu", 40))
m1(2)._1 // "qh"
m1(2)._2 // 30
for( (k,(v1,v2)) <- m1 ) {
  printf("%d: (%s,%d)\n", k, v1, v2)
}

/**
  * 1: (james,20)
  * 2: (qh,30)
  * 3: (qiu,40)
  */

2. 和Java集合间的转换(Scalaj)

  1. Java的List很容易通过List.toArray转换到Array,和Scala中的Array是等价的,可使用map、filter等。

  2. 使用第三方的scalaj扩展包(需自行下载设置classpath)

//例子1:
val a1 = new java.util.ArrayList[Int]
a1.add(100); 
a1.add(200); 
a1.add(300);

// 自行转换
val a2 = a1.toArray
a2 map (e=>e.asInstanceOf[Int]) map(2*) filter (300>)

//采用scalaj(https://github.com/scalaj/scalaj-collection)
import scalaj.collection.Imports._
val a3 = a1.asScala
// scala->java
List(1, 2, 3).asJava
Map(1 -> "a", 2 -> "b", 3 -> "c").asJava
Set(1, 2, 3).asJava
// scalaj还可以在java的collection上使用foreach (目前除foreach外,还不支持filter、map)
a1.foreach(println)

2.1 scalaj Java to Scala

Java类型 转换方法
java.lang.Comparable[A] #asScala: scala.math.Ordered[A]
java.util.Comparator[A] #asScala: scala.math.Ordering[A]
java.util.Enumeration[A] #asScala: scala.collection.Iterator[A]
#foreach(A => Unit): Unit
java.util.Iterator[A] #asScala: scala.collection.Iterator[A]
#foreach(A => Unit): Unit
java.lang.Iterable[A] #asScala: scala.collection.Iterable[A]
#foreach(A => Unit): Unit
java.util.List[A] #asScala: scala.collection.Seq[A]
#asScalaMutable: scala.collection.mutable.Seq[A]
java.util.Set[A] #asScala: scala.collection.Set[A]
#asScalaMutable: scala.collection.mutable.Set[A]
java.util.Map[A, B] #asScala: scala.collection.Map[A, B]
#asScalaMutable: scala.collection.mutable.Map[A, B]
#foreach(((A, B)) => Unit): Unit
java.util.Dictionary[A, B] #asScala: scala.collection.mutable.Map[A, B]
#foreach(((A, B)) => Unit): Unit

2.2 scalaj Scala to Java

Scala类型 转换方法
scala.math.Ordered[A] #asJava: java.util.Comparable[A]
scala.math.Ordering[A] #asJava: java.util.Comparator[A]
scala.collection.Iterator[A] #asJava: java.util.Iterator[A]
#asJavaEnumeration: java.util.Enumeration[A]
scala.collection.Iterable[A] #asJava: java.lang.Iterable[A]
scala.collection.Seq[A] #asJava: java.util.List[A]
scala.collection.mutable.Seq[A] #asJava: java.util.List[A]
scala.collection.mutable.Buffer[A] #asJava: java.util.List[A]
scala.collection.Set[A] #asJava: java.util.Set[A]
scala.collection.mutable.Set[A] #asJava: java.util.Set[A]
scala.collection.Map[A, B] #asJava: java.util.Map[A, B]
scala.collection.mutable.Map[A, B]#asJava: java.util.Map[A, B]
#asJavaDictionary: java.util.Dictionary[A, B]

文章作者: hnbian
版权声明: 本博客所有文章除特別声明外,均采用 CC BY 4.0 许可协议。转载请注明来源 hnbian !
评论
 上一篇
【scala系列】8、方法与函数 【scala系列】8、方法与函数
1. 方法 Scala 中使用 def 语句定义方法, val 语句定义函数。 定义方法的通用格式 :def functionName ([参数列表]) : [return type] = { 方法体 } 。 如果一个方法有返回值,方法
2020-04-05
下一篇 
【scala系列】6、容器类型:Set、Seq、Iterator、Tuple、View、Queue、Stack、Stream 【scala系列】6、容器类型:Set、Seq、Iterator、Tuple、View、Queue、Stack、Stream
1. Set 与 BitSet Set(集合)是没有重复的对象集合,所有的元素都是唯一的。 Set(集合)分为可变的和不可变的集合。默认情况下,Scala 使用的是不可变集合,如果要使用可变集合,需要引用 scala.collection
2020-03-28
  目录