Scala—列表（可变ListBuffer、不可变List）用法详解

Scala集合概述-链接

大家可以点击上方链接，先对Scala的集合有一个整体的概念🤣🤣🤣

在 Scala 中，列表（List）分为不可变列表（List）和可变列表（ListBuffer）。

1. 不可变列表（List）

List 是 Scala 中一种不可变的链表数据结构（数据有顺序，可重复） 。一旦创建，就不能修改其内容，但可以通过操作返回新的列表。

• 创建不可变列表

// 创建一个空的 List
val emptyList: List[Int] = List()// 创建一个包含初始元素的 List
val list1: List[Int] = List(1, 2, 3, 4, 5)// 使用 :: 操作符创建 List
val list2: List[Int] = 1 :: 2 :: 3 :: 4 :: 5 :: Nil

• 添加元素：

  • ::：在列表头部添加一个元素
  • :+：在列表尾部添加一个元素
  • +:：在列表头部添加一个元素

  val newList1 = 0 :: list // 在头部添加元素
  val newList2 = list :+ 6 // 在尾部添加元素
  val newList3 = 0 +: list // 在头部添加元素
  

• 删除元素：

  • tail：返回去掉头部元素的列表
  • drop：删除前 n 个元素
  • filter：过滤掉不符合条件的元素

  val tailList = list1.tail // 去掉头部元素
  val dropList = list1.drop(2) // 删除前 2 个元素
  val filteredList = list1.filter(_ % 2 == 0) // 过滤掉奇数
  

• 访问元素：

  • head：返回列表的第一个元素
  • apply：通过索引访问元素
  • length：返回列表的长度

  val headElement = list1.head // 返回第一个元素
  val thirdElement = list1(2) // 通过索引访问第三个元素
  val length = list1.length // 返回列表的长度
  

• 遍历元素：

  • foreach：遍历所有元素
  • map：映射所有元素
  • filter：过滤元素

  list1.foreach(println) // 遍历并打印所有元素val squaredList = list1.map(x => x * x) // 映射所有元素
  println(squaredList.mkString(", ")) // 输出: 1, 4, 9, 16, 25val evenNumbers = list1.filter(_ % 2 == 0) // 过滤偶数
  println(evenNumbers.mkString(", ")) // 输出: 2, 4
  

---

1. 合并列表

   • ++：合并两个列表

   val list1 = List(1, 2, 3)
   val list2 = List(4, 5, 6)
   val combinedList = list1 ++ list2 // 结果: List(1, 2, 3, 4, 5, 6)
   

2. 反转列表

   • reverse：反转列表

   val reversedList = list1.reverse // 结果: List(3, 2, 1)
   

3. 排序

   • sorted：按自然顺序排序
   • sortWith：使用自定义比较器排序

   val sortedList = list1.sorted // 结果: List(1, 2, 3)
   val customSortedList = list1.sortWith(_ > _) // 结果: List(3, 2, 1)
   

4. 查找元素

   • contains：检查列表是否包含某个元素
   • indexOf：查找元素的索引
   • lastIndexOf：查找元素的最后一个索引

   val contains2 = list1.contains(2) // 结果: true
   val index = list1.indexOf(2) // 结果: 1
   val lastIndex = list1.lastIndexOf(2) // 结果: 1
   

5. 切片操作

   • slice：返回列表的一部分
   • take：返回前 n 个元素
   • drop：删除前 n 个元素
   • splitAt：将列表分成两部分

   val sliceList = list1.slice(1, 3) // 结果: List(2, 3)
   val takeList = list1.take(2) // 结果: List(1, 2)
   val dropList = list1.drop(2) // 结果: List(3)
   val (left, right) = list1.splitAt(2) // 结果: (List(1, 2), List(3))
   

6. 转换操作

   • mkString：将列表转换为字符串
   • toString：返回列表的字符串表示

   val stringRepresentation = list1.mkString(", ") // 结果: "1, 2, 3"
   val toStringRepresentation = list1.toString // 结果: "List(1, 2, 3)"
   

7. 聚合操作

   • foldLeft：从左到右聚合
   • foldRight：从右到左聚合
   • reduce：聚合所有元素

   val sum = list1.foldLeft(0)(_ + _) // 结果: 6
   val product = list1.foldRight(1)(_ * _) // 结果: 6
   val max = list1.reduce((a, b) => if (a > b) a else b) // 结果: 3
   

8. 分组操作

   • groupBy：根据某个条件分组

   val grouped = list1.groupBy(_ % 2 == 0) // 结果: Map(false -> List(1, 3), true -> List(2))
   

---

2. 可变列表（ListBuffer）

ListBuffer 是 Scala 中一个可变的列表类，位于 scala.collection.mutable 包中。可以高效地添加和删除元素。

• 创建可变列表

import scala.collection.mutable.ListBuffer// 创建一个空的 ListBuffer
val buffer = ListBuffer[Int]()// 创建一个包含初始元素的 ListBuffer
val buffer2 = ListBuffer(1, 2, 3, 4, 5)

• 添加元素：
  • +=：在列表末尾添加一个元素
  • ++=：在列表末尾添加多个元素
  • prepend：在列表头部添加一个或多个元素

---

buffer += 1 // 在末尾添加一个元素
buffer ++= List(2, 3, 4) // 在末尾添加多个元素
buffer.prepend(0) // 在头部添加一个元素
buffer.prependAll(List(-1, -2)) // 在头部添加多个元素

• 删除元素：
  • -=：删除一个元素
  • --=：删除多个元素
  • remove：删除指定位置的元素

---

buffer -= 1 // 删除一个元素
buffer --= List(2, 3) // 删除多个元素
buffer.remove(0) // 删除第一个元素

• 访问和修改元素：
  • 索引访问：使用索引访问和修改元素

---

val firstElement = buffer(0) // 访问第一个元素
buffer(0) = 10 // 修改第一个元素

• 遍历元素：
  • foreach：遍历所有元素
  • map：映射所有元素
  • filter：过滤元素

---

buffer.foreach(println) // 遍历并打印所有元素val squaredBuffer = buffer.map(x => x * x) // 映射所有元素
println(squaredBuffer.mkString(", ")) // 输出: 100, 36, 16val evenNumbersBuffer = buffer.filter(_ % 2 == 0) // 过滤偶数
println(evenNumbersBuffer.mkString(", ")) // 输出: 36

• 转换为其他集合类型：
  • toList：转换为不可变的 List
  • toArray：转换为数组

---

val list = buffer.toList // 转换为不可变的 List
val array = buffer.toArray // 转换为数组

---

1. 合并列表

   • ++=：合并两个列表

   val buffer1 = ListBuffer(1, 2, 3)
   val buffer2 = ListBuffer(4, 5, 6)
   buffer1 ++= buffer2 // 结果: ListBuffer(1, 2, 3, 4, 5, 6)
   

2. 反转列表

   • reverse：反转列表

   val reversedBuffer = buffer1.reverse // 结果: ListBuffer(6, 5, 4, 3, 2, 1)
   

3. 排序

   • sorted：按自然顺序排序
   • sortWith：使用自定义比较器排序

   val sortedBuffer = buffer1.sorted // 结果: ListBuffer(1, 2, 3, 4, 5, 6)
   val customSortedBuffer = buffer1.sortWith(_ > _) // 结果: ListBuffer(6, 5, 4, 3, 2, 1)
   

4. 查找元素

   • contains：检查列表是否包含某个元素
   • indexOf：查找元素的索引
   • lastIndexOf：查找元素的最后一个索引

   val contains2 = buffer1.contains(2) // 结果: true
   val index = buffer1.indexOf(2) // 结果: 1
   val lastIndex = buffer1.lastIndexOf(2) // 结果: 1
   

5. 切片操作

   • slice：返回列表的一部分
   • take：返回前 n 个元素
   • drop：删除前 n 个元素
   • splitAt：将列表分成两部分

   val sliceBuffer = buffer1.slice(1, 3) // 结果: ListBuffer(2, 3)
   val takeBuffer = buffer1.take(2) // 结果: ListBuffer(1, 2)
   val dropBuffer = buffer1.drop(2) // 结果: ListBuffer(3, 4, 5, 6)
   val (leftBuffer, rightBuffer) = buffer1.splitAt(2) // 结果: (ListBuffer(1, 2), ListBuffer(3, 4, 5, 6))
   

6. 转换操作

   • mkString：将列表转换为字符串
   • toString：返回列表的字符串表示

   val stringRepresentation = buffer1.mkString(", ") // 结果: "1, 2, 3, 4, 5, 6"
   val toStringRepresentation = buffer1.toString // 结果: "ListBuffer(1, 2, 3, 4, 5, 6)"
   

7. 聚合操作

   • foldLeft：从左到右聚合
   • foldRight：从右到左聚合
   • reduce：聚合所有元素

   val sum = buffer1.foldLeft(0)(_ + _) // 结果: 21
   val product = buffer1.foldRight(1)(_ * _) // 结果: 720
   val max = buffer1.reduce((a, b) => if (a > b) a else b) // 结果: 6
   

8. 分组操作

   • groupBy：根据某个条件分组

   val grouped = buffer1.groupBy(_ % 2 == 0) // 结果: Map(false -> ListBuffer(1, 3, 5), true -> ListBuffer(2, 4, 6))
   

---