第7章 Scala集合
7.1 简介
-
scala.collection.immutable
-
scala.collection.mutable
7.2 数组
-
不可变数组
package chapter07 object Test01_ImmutableArray { def main(args: Array[String]): Unit = { // 1. 创建数组 val arr: Array[Int] = new Array[Int](10) arr(9) = 9 println(arr.mkString(",")) // 另一种创建方式 val arr2 = Array[Int](1, 2, 3, 4, 65) // 2. 数组操作-（由于是不可变数组，增删不能改变）改查 // 访问元素 println(arr2.mkString(",")) arr2(0) = 100 println(arr2.apply(0)) arr2.update(0, 199) println(arr2.mkString(",")) // 3. 数组的遍历 // for循环 for (i <- arr2.indices) { println(arr2(i)) } // 增强for循环 for (ele <- arr2) { println(ele) } // 迭代器 val iterator: Iterator[Int] = arr2.iterator println("++++++++++迭代器+++++++++++++++") while (iterator.hasNext) { println(iterator.next()) } // foreach arr2.foreach((ele: Int) => { println(ele) }) arr2.foreach(println(_)) println(arr2.mkString("----")) // 3. 添加元素，由于是不可变数组，因此添加元素之后，生成一个新的数组 // 30------199------2------3------4------65------2 val array: Array[Any] = arr2.:+(2).+:(30) // 往后追加元素 :+,往前追加元素 +: 2 +: arr2 :+ 10 :+ 10 println(array.mkString("------")) arr2 ++ Array(2) } } -
可变数组
package chapter07 import scala.collection.mutable import scala.collection.mutable.ArrayBuffer object Test02_mutableArrayBuff { def main(args: Array[String]): Unit = { // 1. 创建一个可变数组,无任何元素 val arr = new ArrayBuffer[Int]() println(arr.mkString("--")) arr += 10 println(arr.mkString("--")) // 另一种创建方法 val arr2: ArrayBuffer[Int] = ArrayBuffer(19, 10, 2) println(arr2) println(arr2.mkString("===")) // 2. 访问元素 println(arr2(0)) // 3. 添加元素 val newArr = arr2 :+ 10 println(newArr == arr2) println(arr2) // 不建议这样的操作，建议arr2 += 10 val arr3 = arr2 += 10 println(arr3 == arr2) 101 +=: arr3 println(arr3) // 可变集合推荐调用方法 arr3.append(10, 1999) arr3.prepend(10092) arr3.insert(2, 22222) println(arr3) // 添加一个数组 arr3.insertAll(1, arr) println(arr3) // 4. 删除元素，指定位置 arr3.remove(1) println(arr3) arr3.remove(1, 2) println(arr3) // 删除特定值 arr3 -= 10 println(arr3) // 5. 可变数组与不可变数组之间的转换 val arr5 = ArrayBuffer(10, 2, 3, 1) val newArr5: Array[Int] = arr5.toArray println(newArr5.mkString("-")) val buffer: mutable.Buffer[Int] = newArr5.toBuffer println(buffer) println(newArr5) } } -
多维度数组
package chapter07 object Test03_MulArray { def main(args: Array[String]): Unit = { // 创建2维数组 val array: Array[Array[Int]] = Array.ofDim[Int](2, 3) // 访问元素 array(0)(2) = 10 println(array.mkString("-")) for (i <- 0 until array.length; j <- 0 until array(i).length) { println(array(i)(j)) } val array1: Array[Array[String]] = Array.ofDim[String](2, 3) for (i <- array1.indices; j <- array1(i).indices) { print(array1(i)(j) + "\t") if (j == array1(i).length - 1) println() } array.foreach( (line) => { line.foreach(println(_)) } ) array.foreach( _.foreach(println) ) } }
7.3 列表List
-
不可变列表
package chapter07 object Test04_ImmutableList { def main(args: Array[String]): Unit = { // 列表 // 1. 创建List，不能用class创建，只能用伴生对象创建 // sealed abstract class List 中sealed表示List类的子类只能在本文件创建 val list1 = List(1, 2, 3, 4, 5, 6) println(list1) // 2. 访问和遍历元素 println(list1(0)) // 此处不能像Array更改某个位置的值 // list1(0) = 10 error // list1.foreach(println) // 3. 添加元素 // 头部添加 10 +: list1 val list2: List[Int] = list1.+:(10) // 尾部添加 list1 :+ 19 val list3: List[Int] = list1.:+(19) println(list2) println(list3) // 双冒号主要用于创建一个列表 val list4 = list1.::(51) println(list4) println(52 :: list1) // 创建一个列表 val list5 = 32 :: 39 :: Nil // 4. 列表合并 val list6 = list4 :: list5 // List(List(51, 1, 2, 3, 4, 5, 6), 32, 39) println(list6) // 3冒号用于列表拼接，扁平化合并 val list7 = list4 ::: list5 // List(51, 1, 2, 3, 4, 5, 6, 32, 39) println(list7) // 等价，列表拼接，扁平化合并 println(list4 ++ list5) } } -
可变列表
package chapter07 import scala.collection.mutable.ListBuffer object Test05_MutableListBuffer { def main(args: Array[String]): Unit = { // 1. 创建可变列表 val list1 = new ListBuffer[Int]() val list2 = ListBuffer(12, 13, 29) println(list1) println(list2) // 2. 添加元素，使用方法函数 list1.append(1, 2, 3) list1.insert(1, 19, 22) list2.prepend(34, 2) println(list1) println(list2) // 3. 合并list ++ 会返回新的对象，++= 会更改 val list3 = list1 ++ list2 println(list3) list1 ++= list2 println(list1) // 4. 修改元素 list2(2) = 3333 list2.update(0, 99) println(list2) // 5. 删除元素 // 指定位置删除 list2.remove(2) // 指定元素删除 list2 -= 29 println(list2) } }
7.4 Set 集合
-
不可变Set
package chapter07 object Test06_ImmutableSet { def main(args: Array[String]): Unit = { // 1. 创建Set，new Set()不能创建，Set为特征，因此只能用伴生对象创建 val set1 = Set(1, 2, 3, 34, 2, 3) println(set1) // 2. 添加元素 println("=========2. 添加元素============") val set2 = set1 + 10 + 10 + 20 + 20 + 30 println(set2) // 3. 合并set println("=========3. 合并set============") val set3 = Set(1, 2, 3, 4, 9, 10) val set4 = set2 ++ set3 println(set4) // 4. 删除元素 println("=========4. 删除元素============") val set5 = set4 - 30 println(set4) println(set5) } } -
可变Set
package chapter07 import scala.collection.mutable object Test07_MutableSet { def main(args: Array[String]): Unit = { // 1. 创建可变set val set1: mutable.Set[Int] = mutable.Set(1, 2, 3, 4, 10) println(set1) // 2. 添加元素,使用方法名 println("============2. 添加元素============") val flag1 = set1.add(12) println(set1) println(flag1) val flag2 = set1.add(12) println(set1) println(flag2) // 3. 删除元素 println("============3. 删除元素============") set1.remove(12) println(set1) // 4. 合并两个set ++= println("============4. 合并两个set============") val set3 = mutable.Set(111, 222, 3, 4, 101) println(set1) println(set3) set1 ++= set3 println(set1) println(set3) } }
7.5 Map 集合
-
不可变Map
package chapter07 object Test08_ImmutableMap { def main(args: Array[String]): Unit = { // 1. 创建Map val map1: Map[String, Int] = Map[String, Int]("scc" -> 18, "hello" -> 10) println(map1) println(map1.getClass) val map0 = Map[String, Int]() println(map0) println(map0.getClass) // 2. 遍历元素 map1.foreach(println(_)) map1.foreach(kv => println(s"key is ${kv._1}, value is ${kv._2}")) // 3. 取map中所有key或者value /** * println(s"$key-->${map1.get(key)}") * scc-->Some(18) * hello-->Some(10) */ for (key <- map1.keys) { println(s"$key-->${map1.get(key)}") println(s"$key-->${map1.getOrElse(key, 0)}") } for (value <- map1.values) { println(value) } } } -
可变Map
package chapter07 import scala.collection.mutable object Test09_MutableMap { def main(args: Array[String]): Unit = { // 1. 创建Map val map1 = mutable.Map[String, Int]("scc" -> 18, "hello" -> 10) println(map1) println(map1.getClass) // 2. 添加元素 map1.put("zyy", 19) println(map1) map1 += (("a", 20), ("b", 22)) println(map1) // 3. 删除元素 map1.remove("zyy") map1 -= "d" println(map1) // 4. 修改元素 map1.update("a", 209) println(map1) // 5. 合并两个Map val map2 = mutable.Map[String, Int]("x" -> 108, "hello" -> 11) println(map1) println(map2) map1 ++= map2 println(map1) println(map2) val map3: mutable.Map[String, Int] = map1 ++ map2 // 6. immutable.map 和 mutable.map 互转 val map4: Map[String, Int] = map3.toMap val map5: mutable.Map[String, Int] = collection.mutable.Map(map4.toSeq: _*) } }
7.6 元组
package chapter07
object Test10_Tuple {
def main(args: Array[String]): Unit = {
// 1. 创建元组
val tuple1: (String, Int, Char, Boolean) = ("hello", 100, 'a', true)
println(tuple1)
// 2. 访问数据
println(tuple1._1)
println(tuple1._2)
println(tuple1._3)
println(tuple1._4)
// 索引从0开始，建议使用下划线_
println(tuple1.productElement(1))
// 3. 遍历元组数据
for (ele <- tuple1.productIterator) {
println(ele)
}
// 4. 嵌套元组
val mulTuple = (12, 0.3, "hello", (23, "scala"), 29)
println(mulTuple._1)
println(mulTuple._4._2)
}
}
7.7 集合常用函数
-
通用属性和操作
package chapter07 object Test11_CommonOp { def main(args: Array[String]): Unit = { val list: List[Int] = List(1, 2, 3, 4) val set = Set(1, 2, 3, 4) // 1. 获取集合长度 println(list.length) // 3. 获取集合大小 println(list.size) println(set.size) // 3. 循环遍历 for (elem <- list){ println(elem) } // 4. 迭代器 for (elem <- list.iterator){ println(elem) } val iterator: Iterator[Int] = list.iterator while (iterator.hasNext){ println(iterator.next()) } // 5. 生成字符串 println(list) println(set) println(list.mkString("--")) // 6. 是否包含 println(list.contains(1)) println(list.contains(5)) println(set.contains(2)) } } -
衍生集合
package chapter07 object Test12_DerivedCollection { def main(args: Array[String]): Unit = { val list1: List[Int] = List(1, 3, 5, 7, 2, 89) val list2: List[Int] = List(3, 7, 2, 45, 4, 8, 19) // 1. 获取集合的头 println("=============1. 获取集合的头=============") println(list1.head) // 2. 获取集合的尾(不是头的尾) println("=============2. 获取集合的尾(不是头的尾)=============") println(list1.tail) // 3. 获取集合的最后一个元素 println("=============3. 获取集合的最后一个元素=============") println(list1.last) // 4. 获取集合初始元素（不包含最后一个） println("=============4. 获取集合初始元素（不包含最后一个）=============") println(list1.init) // 5. 翻转 println("=============5. 翻转=============") println(list1.reverse) // 6. 取前(后)n个元素 println("=============6. 取前(后)n个元素=============") println(list1.take(3)) println(list1.takeRight(4)) // 7. 去掉前(后)n个元素 println("=============7. 去掉前(后)n个元素=============") println(list1.drop(3)) println(list1.dropRight(4)) println("=============以下操作，涉及两个集合操作=============") // 8. 交集 println("=============8. 交集=============") val intersect = list1 intersect list2 println(intersect) // 9. 并集 println("=============9. 并集=============") val union = list1 union list2 println(union) println(list1 ::: list2) // 10. 差集 println("=============10. 差集=============") val diff1: List[Int] = list1.diff(list2) val diff2: List[Int] = list2.diff(list1) println(diff1) println(diff2) // 11. 拉链，取最小集合长度为准 println("=============11. 拉链，取最小集合长度为准=============") println(s"list1: $list1") println(s"list2: $list2") val zip1: List[(Int, Int)] = list1.zip(list2) val zip2: List[(Int, Int)] = list2.zip(list1) println(s"zip1: $zip1") println(s"zip2: $zip2") // 12. 滑窗 println("=============12. 滑窗=============") // List(1, 3, 5, 7, 2, 89) println(list1) /** * List(1) * List(3) * List(5) * List(7) * List(2) * List(89) */ list1.sliding(1).foreach(println) /** * List(1, 3) * List(3, 5) * List(5, 7) * List(7, 2) * List(2, 89) */ list1.sliding(2).foreach(println) /** * List(1, 3) * List(7, 2) */ list1.sliding(2, 3).foreach(println) /** * 窗口无重复数据，又叫滚动滑动窗口 * List(1, 3) * List(5, 7) * List(2, 89) */ list1.sliding(2, 2).foreach(println) } } -
简单计算函数
package chapter07 object Test13_SimpleOp { def main(args: Array[String]): Unit = { val list: List[Int] = List(5, 1, 8, 2, -3, 4) val list2 = List(("a", 5), ("b", 1), ("c", 8), ("d", 2), ("e", -3), ("f", 4)) // 1. 求和 println(list.sum) val i: Int = list.reduce((a, b) => { a + b }) println(i) // 2. 求积 println(list.product) // 3. 最大值 println(list.max) println(list2.max) println(list2.maxBy(elem => { elem._2 })) println(list2.maxBy(_._2)) // 4. 最小值 println(list.min) // 5. 排序 // 按照第一个位置元素排序 /** * List(-3, 1, 2, 4, 5, 8) * List(8, 5, 4, 2, 1, -3) * List((a,5), (b,1), (c,8), (d,2), (e,-3), (f,4)) * List((f,4), (e,-3), (d,2), (c,8), (b,1), (a,5)) */ println(list.sorted) // 从小到大排序 println(list.sorted(scala.math.Ordering.Int.reverse)) // 从大到小排序 println(list2.sorted) // 从小到大排序 println(list2.sorted(scala.math.Ordering.Tuple2[String, Int].reverse)) // 从大到小排序 // 指定位置元素排序，从大到小 /** * List((c,8), (a,5), (f,4), (d,2), (b,1), (e,-3)) * List((c,8), (a,5), (f,4), (d,2), (b,1), (e,-3)) */ println(list2.sortBy(elem => { elem._2 })(scala.math.Ordering[Int].reverse)) println(list2.sortBy( _._2 )(scala.math.Ordering.Int.reverse)) // 上面方法太麻烦，使用sortWith进行简化 println(list.sortWith(_ < _)) println(list.sortWith(_ > _)) list2.sortWith((a, b) => { a._2 > b._2 }) /** * sorted：适合单集合的升降序 * * sortBy：适合对单个或多个属性的排序，代码量比较少，推荐使用这种 * * sortWith：适合定制化场景比较高的排序规则，比较灵活，也能支持单个或多个属性的排序，但代码量稍多，内部实际是通过java里面的Comparator接口来完成排序的。 * */ } } -
高级计算函数
package chapter07 object Test14_HighLevelFunction_Map { def main(args: Array[String]): Unit = { /** * List(2, 4, 6, 8) * List(2, 4, 6, 8, 10, 12, 14, 16, 18) * List(List(1, 2, 3), List(4, 5), List(6, 7, 8, 9)) * List(1, 2, 3, 4, 5, 6, 7, 8, 9) * List(Hello, Scala, Hello, World) * List(Hello, Scala, Hello, World) * Map(1 -> List(1, 3, 5, 7, 9), 0 -> List(2, 4, 6, 8)) * Map(2 -> List(2, 5, 8), 1 -> List(1, 4, 7), 0 -> List(3, 6, 9)) * Map(S -> List(Scala), W -> List(World), H -> List(Hello, Hello)) * */ val list = List(1, 2, 3, 4, 5, 6, 7, 8, 9) // 1. 过滤 val evenList: List[Int] = list.filter(_ % 2 == 0) println(evenList) // 2. 转化/映射 map val multiply2: List[Int] = list.map(_ * 2) println(multiply2) // 3. 扁平化 val nestedList: List[List[Int]] = List(List(1, 2, 3), List(4, 5), List(6, 7, 8, 9)) println(nestedList) val flattenList: List[Int] = nestedList.flatten println(flattenList) // 4. 扁平化和映射 flatMap,先map，再flatten // 将一组单词，进行分词，再保存成单词列表 val strings: List[String] = List("Hello Scala", "Hello World") println(strings.map(_.split(" ")).flatten) println(strings.flatMap(_.split(" "))) // 5. 分组，groupBy // 直接分成奇数和偶数两组 println(list.groupBy(_ % 2)) println(list.groupBy(_ % 3)) // 给定一组单词，按照单词的首字母进行分组 val stringList1: List[String] = List("Hello Scala", "Hello World") println(stringList1.flatMap(_.split(" ")).groupBy((elem) => { elem.charAt(0) })) } }package chapter07 object Test15_HighLevelFunction_Reduce { def main(args: Array[String]): Unit = { val list = List(1, 2, 3, 4) // 1. reduce println(list.reduce(_ + _)) println(list.reduceLeft(_ + _)) println(list.reduceRight(_ + _)) println("===============================") /** * -24 * -24 * 6 */ val list2 = List(3, 4, 5, 8, 10) println(list2.reduce(_ - _)) println(list2.reduceLeft(_ - _)) println(list2.reduceRight(_ - _)) // (3-(4-(5-(8-10)))) println("==============2. fold=================") // 2. fold /** * ==============2. fold================= * 20 * 20 * -5 */ println(list.fold(10)(_ + _)) println(list.foldLeft(10)(_ + _)) println(list2.foldRight(11)(_ - _)) // (3-(4-(5-(8-(10-10))))) } } -
应用案例-合并Map
package chapter07 import scala.collection.mutable object Test16_MergeMap { def main(args: Array[String]): Unit = { // 遍历map1 val map1 = Map("a" -> 1, "b" -> 3, "c" -> 6) // 更新map2 val map2 = mutable.Map("a" -> 6, "b" -> 2, "c" -> 9, "d" -> 3) println(map1) println(map2) map1.foreach(elem => { val value1 = elem._2 val value2 = map2.getOrElse(elem._1, 0) map2.update(elem._1, value1 + value2) }) println(map2) map1.foldLeft(map2)( (mergedMap, kv) => { val key = kv._1 val value = kv._2 mergedMap.update(key, mergedMap.getOrElse(key, 0) + value) mergedMap }) println(map2) } } -
队列
-
并行集合
