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)
Java的List
很容易通过List.toArray转换到Array,和Scala中的Array是等价的,可使用map、filter等。 使用第三方的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] |