四、Map学习
在Scala中，把哈希表这种数据结构叫做映射。
Map是一个对偶，映射的k一v键值对的集合，在一个map中可以包含若干组k一v映射关系，前提条件是k不能重复。
Scala中的Map存储的内容是键值对（key一value），Scala中不可变的Map是有序的，可变的Map是无序的。Scala中，有可变Map （scala. collection. mutable. Map）和不可变Map（scala. collection. immutablE. Map）。
1.不可变映射
val personAges = Map("A1ice" -> 20 , "Job" -> 28 , "Garry " ->18)
上述代码构造出一个不可变的Map[String,Int]，其值不能被改变。
也可以用此方法创建Map
val personAges = Map(("A1ice" -> 20),("Job" -> 28),("Garry" ->18))
注: ->用来创建元组，“sa” -> 1即(“Alice”,20)
2.可变映射
如果你想要一个可变映射，则用
val personAges = scala.collection.mutable.Map("A1ice"->20 , "Job"->28 , "Garry"->18)
如果想从一个空的映射开始，你需要选定一个映射实现并给出类型参数:
val personAgesI = new scala.collection.mutable.HashMap[String,Int]
在Scala中，映射是对偶的集合。对偶简单地说就是两个值构成的组，这两个值并不一定是同一个类型的，比如(“Alice”,20)
不可变Map示例代码：
package arrayDemo /** * @author : 蔡政洁 * @email :caizhengjie888@icloud.com * @date : 2020/9/16 * @time : 3:19 下午 */ object ImmutableMapOps { // Scala不可变map的操作 def main(args: Array[String]): Unit = { val personMap = Map[String,Int]( "张三"-> 20, "李四"-> 21, "王五"-> 22, "小白"-> 23 ) val key = "小白" if (personMap.contains(key)){ // 获取map中的元素 val optionAge:Option[Int] = personMap.get(key) val age1 = optionAge.get println(age1) // 获取map中的元素方式二 val age2 = personMap(key) println(age2) } else { // 如果key存在，则获取对应的value，不存在，则返回默认值 val age = personMap.getOrElse(key,-1) println(age) } // 不可变的map不能修改，增加操作 // 删除,drop删除会返回一个新的集合，原集合不会改变 println(personMap) println(personMap.drop(1)) println(personMap) } }
运行结果：
23 23 Map(张三 -> 20, 李四 -> 21, 王五 -> 22, 小白 -> 23) Map(李四 -> 21, 王五 -> 22, 小白 -> 23) Map(张三 -> 20, 李四 -> 21, 王五 -> 22, 小白 -> 23)
可变Map示例代码：
package arrayDemo import scala.collection.mutable /** * @author : 蔡政洁 * @email :caizhengjie888@icloud.com * @date : 2020/9/16 * @time : 4:07 下午 */ object MutableMapOps { // Scala可变map操作 def main(args: Array[String]): Unit = { val map = mutable.Map[String,Int]( "张三"->23 ) println("原始map元素："+map) // 添加元素 map("李四") = 14 println(map) // 修改元素 map("李四") = 15 println(map) // 存在即修改，不存在即添加 map.put("小白",34) map.put("小黑",35) println(map) // 删除操作 println("map.drop(1):"+map.drop(1)) // 删除集合中的起始集合，会返回一个新的集合，原集合不会改变 println(map) val value:Option[Int] = map.remove("小白") // 如果有小白删除小白，原集合改变。如果没有小白，则返回-1 println(value.getOrElse(-1)) println(map) // map的遍历 println("------scala的map遍历推荐方式一") val keys = map.keys for (key <- keys){ val value = map(key) println(key+"---->"+value) } println("------scala的map遍历推荐方式二") for ((k,v) <- map){ println(k+"---->"+v) } println("------scala的map遍历推荐方式三") for (kv <- map){ println(kv._1+"---->"+kv._2) } println("------scala的map遍历推荐方式四") map.foreach(kv => { println(kv._1+"---->"+kv._2) }) } }
运行结果：
原始map元素：Map(张三 -> 23) Map(张三 -> 23, 李四 -> 14) Map(张三 -> 23, 李四 -> 15) Map(张三 -> 23, 李四 -> 15, 小黑 -> 35, 小白 -> 34) map.drop(1):Map(李四 -> 15, 小黑 -> 35, 小白 -> 34) Map(张三 -> 23, 李四 -> 15, 小黑 -> 35, 小白 -> 34) 34 Map(张三 -> 23, 李四 -> 15, 小黑 -> 35) ------scala的map遍历推荐方式一 张三---->23 李四---->15 小黑---->35 ------scala的map遍历推荐方式二 张三---->23 李四---->15 小黑---->35 ------scala的map遍历推荐方式三 张三---->23 李四---->15 小黑---->35 ------scala的map遍历推荐方式四 张三---->23 李四---->15 小黑---->35
五、元祖Tuple学习
映射是键/值对偶的集合。对偶足元组（ tuple） 的最简单形态，元组是不同类型的值的聚集。元组的值是通过将单个的值包含在圆括号中构成的。例如: (1, 3.14,“Fred”)是一 一个元组，类型为:
Tuple3 [Int,Double,java.lang.String]
val t = (1, 3.14,"Fred")
需要注意的是:和数组或字符串中的位置不同，元组的各组元从1开始，而不是0。你可以把t._2写为t _2，即用空格而不是句点，但不能写成t_2
Tuple示例代码：
package arrayDemo /** * @author : 蔡政洁 * @email :caizhengjie888@icloud.com * @date : 2020/9/16 * @time : 5:09 下午 */ object TupleOps { // Scala集合体系之tuple元祖的操作 def main(args: Array[String]): Unit = { // 构建一个元祖 val tuple1 = new Tuple2[String,Int]("张三",13) val tuple2 = ("李四",15) // 获取元祖中的值 val name = tuple1._1 val age = tuple1._2 println(s"name:${name},age:${age}") // 推荐元祖的定义的方式 val tuple3 = ("spring","summer","autumn","winter") val (spring,summer,autumn,winter) = ("spring","summer","autumn","winter") println(spring == tuple3._1) println(summer == tuple3._2) println(autumn == tuple3._3) println(winter == tuple3._4) // 元祖的遍历，需要迭代器才能遍历 for(t <- tuple3.productIterator){ println(t) } } }
运行结果：
name:张三,age:13 true true true true spring summer autumn winter
六、zip学习
zip操作，就是将两个单列的集合，组合成双列的集合，集合中的每一组元素就是 上述学习过的tuple。
val province = Array("山东","河南","陕西","福建") val capital = Array("济南","郑州","西安","福州") // zip拉链操 val pcs = province.zip(capital) for((p,c)<-pcs){ print(p+"--->"+c) }
zip示例代码：
package arrayDemo /** * @author : 蔡政洁 * @email :caizhengjie888@icloud.com * @date : 2020/9/16 * @time : 7:49 下午 */ object ZipOps { // scala zip 拉链操作 def main(args: Array[String]): Unit = { val province = Array("山东","河南","陕西","福建") val capital = Array("济南","郑州","西安","福州","广州") val pcs:Array[(String,String)] = province.zip(capital) //会将两个集合裁剪到一样长 for (pc <- pcs){ val p = pc._1 val c = pc._2 println(s"province:${p},captial:${c}") } println("----------------zipAll----------------------") /** * zipAll会使用后面的参数对没有匹配上的值自动填充 * 其中第一个元素（A），会和第二个集合中的多余的元素进行配对 * 其中第二个元素（B），会和第一个集合中的多余的元素进行配对 */ val pcAll:Array[(String,String)] = province.zipAll(capital,"江苏","南京") //会将两个集合裁剪到一样长 for (pc <- pcAll){ val p = pc._1 val c = pc._2 println(s"province:${p},captial:${c}") } } }
运行结果：
province:山东,captial:济南 province:河南,captial:郑州 province:陕西,captial:西安 province:福建,captial:福州 ----------------zipAll---------------------- province:山东,captial:济南 province:河南,captial:郑州 province:陕西,captial:西安 province:福建,captial:福州 province:江苏,captial:广州
