第7章 Scala集合

第7章 Scala集合

7.1 简介

​

​

• scala.collection.immutable

  ​

• scala.collection.mutable

  ​

7.2 数组

​

1. 不可变数组

   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)
   
     }
   
   }
   
   

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)
     
     }
   
   }
   

3. 多维度数组

   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

1. 不可变列表

   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)
     }
   
   }
   
   

2. 可变列表

   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 集合

1. 不可变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)
   
   
     }
   
   }
   
   

2. 可变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 集合

​

1. 不可变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)
       }
   
   
     }
   
   
   }
   
   

2. 可变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 集合常用函数

1. 通用属性和操作

   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))
     
     }
   
   }
   
   

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)
     }
   
   }
   
   

3. 简单计算函数

   ​

   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接口来完成排序的。
        *
        */
     }
   
   }
   
   

4. 高级计算函数

   ​​

   ​

   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)))))
   
     }
   
   }
   
   

5. 应用案例-合并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)
   
   
     }
   
   }
   
   

6. 队列

   ​

7. 并行集合

   ​