feat:线下课：集合_Seq、Set、Map及常用操作

src/main/scala/chapter4/Demo1Seq.scala

@@ -0,0 +1,57 @@
+package chapter4
+
+object Demo1Seq {
+  def main(args: Array[String]): Unit = {
+    Traversable(1, 2, 3)
+    Iterable("x", "y", "z")
+    Map("x" -> 24, "y" -> 25, "z" -> 26)
+
+    // 1. 使用工厂方法创建序列，默认是不可变集合
+    val seq = Seq(1, 2, 3, 4, 5)
+
+    // 2. 通过索引下标访问元素，注意：索引下标从0开始
+    val firstEle = seq(0)
+    val firstEle1 = seq.head
+    //    seq.tail
+    println(s"firstEle = ${firstEle}")
+    println(s"firstEle1 = ${firstEle1}")
+    // 3. 添加元素，添加元素会返回一个新的集合
+    val seq1 = seq :+ 6
+    println(s"seq = ${seq}")
+    println(s"seq1 = ${seq1}")
+
+    // 4. 遍历
+    seq.foreach(println)  // 输出1 2 3 4 5
+
+    // 5. 排序
+    val sortedSeq = seq.sorted  // 排序，结果为Seq(1, 2, 3, 4, 5)
+    //    val descOrder: (Int, Int) => Boolean = (a, b) => a > b
+    //    val customSortedSeq = seq.sortWith(descOrder)  // 自定义排序，结果为Seq(5, 4, 3, 2, 1)
+    val customSortedSeq = seq.sortWith(_ > _)  // 自定义排序，结果为Seq(5, 4, 3, 2, 1)
+
+    println(s"sortedSeq = ${sortedSeq}")
+    println(s"customSortedSeq = ${customSortedSeq}")
+
+    // 6. 反转
+    val reversedSeq = seq.reverse  // 结果为Seq(5, 4, 3, 2, 1)
+    println(s"reversedSeq = ${reversedSeq}")
+
+    // 7. 查找元素
+    val contains4 = seq.contains(4)  // 检查是否包含4，结果为true
+    val indexOf3 = seq.indexOf(3)    // 查找3的索引，结果为2
+    println(s"contains4 = ${contains4}")
+    println(s"indexOf3 = ${indexOf3}")
+    // 8. 更新
+    val updatedSeq = seq.updated(1, 10)  // 更新索引1的元素为10，结果为Seq(1, 10, 3, 4, 5)
+    println(s"updatedSeq = ${updatedSeq}")
+
+    // 9. 多集操作
+    val seqA = Seq(1, 2, 3, 4)
+    val seqB = Seq(3, 4, 5, 6)
+    // 交集、并集、差集
+    val intersection = seqA.intersect(seqB)  // 结果为Seq(3, 4)
+    val difference = seqA.diff(seqB)          // 结果为Seq(1, 2)
+    println(s"intersection = ${intersection}")
+    println(s"difference = ${difference}")
+  }
+}

src/main/scala/chapter4/Demo2Set.scala

@@ -0,0 +1,32 @@
+package chapter4
+
+object Demo2Set {
+  def main(args: Array[String]): Unit = {
+    // 创建不可变Set
+    //无序不可重复
+    val immutableSet = Set(1, 2, 3, 4, 5, 1)
+    println("不可变Set: " + immutableSet) // 输出: 不可变Set(5, 1, 2, 3, 4)
+
+    // 检查元素是否存在
+    println("元素 3 存在? " + immutableSet.contains(3)) // 输出: 元素 3 存在? true
+    println("元素 6 存在? " + immutableSet.contains(6)) // 输出: 元素 6 存在? false
+
+    // 添加元素
+    val newSet = immutableSet + 6
+    println("添加元素后的不可变Set: " + newSet) // 输出: 添加元素后的不可变Set: Set(1, 2, 3, 4, 5, 6)
+
+    // 删除元素
+    val updatedSet = immutableSet - 3
+    println("删除元素后的不可变Set: " + updatedSet) // 输出: 删除元素后的不可变Set: Set(1, 2, 4, 5)
+    val updatedSet2 = immutableSet - 10
+    println("删除元素后的不可变Set: " + updatedSet2) // 输出: 删除元素后的不可变Set: Set(1, 2, 4, 5)
+
+    // 集合操作
+    val set1 = Set(1, 2, 3)
+    val set2 = Set(2, 3, 4)
+
+    println("交集: " + (set1 intersect set2)) // 输出: 交集: Set(2, 3)
+    println("并集: " + (set1 union set2)) // 输出: 并集: Set(1, 2, 3, 4)
+    println("差集: " + (set1 diff set2)) // 输出: 差集: Set(1)
+  }
+}

src/main/scala/chapter4/Demo3Map.scala

@@ -0,0 +1,27 @@
+package chapter4
+
+object Demo3Map {
+
+  def main(args: Array[String]): Unit = {
+    List
+    // 创建不可变Map
+    val immutableMap = Map("A" -> 1, "B" -> 2, "C" -> 3)
+    println("不可变Map: " + immutableMap)  // 输出: 不可变Map: Map(A -> 1, B -> 2, C -> 3)
+
+    // 访问元素
+    println("访问元素 B: " + immutableMap("B"))  // 输出: 访问元素 B: 2
+    //    println("访问元素 D: " + immutableMap("D"))  // 报错，不存在 key为D的元素
+
+    // 添加元素（返回新的Map）
+    val updatedMap = immutableMap + ("D" -> 4)
+    println("添加元素后的不可变Map: " + updatedMap)  // 输出: 添加元素后的不可变Map: Map(A -> 1, B -> 2, C -> 3, D -> 4)
+
+    // 删除元素（返回新的Map）
+    val removedMap = immutableMap - "B"
+    println("删除元素后的不可变Map: " + removedMap)  // 输出: 删除元素后的不可变Map: Map(A -> 1, C -> 3)
+
+    // 检查键是否存在
+    println("键 'A' 是否存在? " + immutableMap.contains("A"))  // 输出: 键 'A' 是否存在? true
+    println("键 'E' 是否存在? " + immutableMap.contains("E"))  // 输出: 键 'E' 是否存在? false
+  }
+}

src/main/scala/chapter4/Demo4Op.scala

@@ -0,0 +1,46 @@
+package chapter4
+
+object Demo4Op {
+  def main(args: Array[String]): Unit = {
+    // 创建示例集合
+    val numbers = List(1, 2, 3, 4, 5)
+    val strings = List("apple", "banana", "cherry")
+
+    // 1. 过滤
+    val evenNumbers = numbers.filter(_ % 2 == 0)
+    println("偶数: " + evenNumbers) // 输出: 偶数: List(2, 4)
+
+    // 2. 转换（map）
+    val doubledNumbers = numbers.map(_ * 2)
+    println("乘以2: " + doubledNumbers) // 输出: 乘以2: List(2, 4, 6, 8, 10)
+
+    // 3. 分组（groupBy）
+    val groupedByLength = strings.groupBy(_.length)
+    println("按长度分组: " + groupedByLength) // 输出: 按长度分组: Map(5 -> List(apple), 6 -> List(banana, cherry))
+
+    // 4. 归约（reduce）
+    val product = numbers.reduce(_ * _)
+    //    val product = numbers.product
+    println("乘积: " + product) // 输出: 乘积: 120
+
+    // 5. 折叠（fold）
+    // fold方法是最通用的聚合操作。它需要一个初始值和一个二元函数作为参数。
+    // 初始值的类型决定了最终结果的类型。二元函数接受两个参数：当前的累计值和集合中的下一个元素。
+    val sum = numbers.fold(0)(_ + _)
+    //    val sum2 = numbers.sum
+    println("和: " + sum) // 输出: 和: 15
+    //    println("和: " + sum2) // 输出: 和: 15
+
+    // 6. 排序（sortBy）
+    val sortedStrings = strings.sortBy(_.length)
+    println("按长度排序: " + sortedStrings) // 输出: 按长度排序: List(apple, cherry, banana)
+
+    // 7. 取前N个（take）
+    val firstThree = numbers.take(3)
+    println("前3个: " + firstThree) // 输出: 前3个: List(1, 2, 3)
+
+    // 8. 跳过前N个（drop）
+    val skipFirst = numbers.drop(1)
+    println("跳过第一个: " + skipFirst) // 输出: 跳过第一个: List(2, 3, 4, 5)
+  }
+}