【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]