（一）List 的定义和介绍
List 是一种有序的数据结构，它是一种链表结构。 [教师画图介绍链表]
[展示]List 创建格式
不可 变 List：
val 列表名称 = List(element1, element2,...)
可变 List : ListBuffer
import scala.collection.mutable.ListBuffer
val 列表名称 = ListBuffer[元素类型](element1, element2,...)
List 是一种有序的数据结构，它是一种链表结构
// 链表示意图： 头节点 → 节点1 → 节点2 → ... → 尾节点(Nil)
// 每个节点包含：数据 + 指向下一个节点的引用
// 不可变List：一旦创建，不能修改，只能创建新的列表
val 省份列表 = List("湖北省", "浙江省", "江苏省")
// 可变List：可以原地修改
import scala.collection.mutable.ListBuffer
val 可变省份列表 = ListBuffer[String]("湖北省", "浙江省")
（二）可变 ListBuffer 的常用方法
1. 添加元素
val list = ListBuffer("湖北", "浙江")
// 添加单个元素
list += "江苏" // 末尾添加
list.append("广东") // 末尾添加
list.prepend("北京") // 开头添加
// 添加多个元素
list ++= List("上海", "重庆") // 批量添加
list.insert(2, "河南") // 在索引2处插入
println(list) // ListBuffer(北京, 湖北, 河南, 浙江, 江苏, 广东, 上海, 重庆)
2. 删除元素
val list = ListBuffer("北京", "湖北", "河南", "浙江", "江苏")
// 删除指定元素
list -= "河南" // 删除第一个匹配项
list.remove(1) // 删除索引1的元素（湖北）
list.remove(0, 2) // 从索引0开始删除2个元素
// 批量删除
list --= List("江苏", "浙江") // 删除多个元素
// 删除满足条件的元素
list.filterInPlace(_ != "北京") // 原地过滤
println(list) // ListBuffer()
3. 元素是否存在
val list = ListBuffer("湖北", "浙江", "江苏")
// 检查元素
val 是否有湖北 = list.contains("湖北") // true
val 索引位置 = list.indexOf("浙江") // 1
val 最后一个索引 = list.lastIndexOf("江苏") // 2
// 检查条件
val 是否有长度大于2 = list.exists(_.length > 2) // false
val 是否全部长度大于1 = list.forall(_.length > 1) // true
4. 合并列表
val list1 = ListBuffer("湖北", "浙江")
val list2 = ListBuffer("江苏", "广东")
// 合并列表（修改原列表）
list1 ++= list2 // list1 变为 ListBuffer(湖北, 浙江, 江苏, 广东)
// 创建新列表
val 合并列表 = list1 ++ list2 // 不改变原列表
// 连接操作
val 连接结果 = list1.concat(list2) // 同 ++=
5. List 的遍历
val 省份列表 = ListBuffer("湖北", "浙江", "江苏", "广东")
// 1. for循环
for (省份 <- 省份列表) {
println(省份)
}
// 2. foreach方法
省份列表.foreach(println)
// 3. 带索引的遍历
for ((省份, 索引) <- 省份列表.zipWithIndex) {
println(s"第${索引 + 1}个省份：$省份")
}
// 4. 使用for推导式
val 带编号的列表 = for (省份 <- 省份列表) yield s"省份：$省份"
（三）不可变 List 的常用方法
1. 添加元素（创建新列表）
val 原列表 = List("湖北", "浙江")
// 在开头添加（高效）
val 新列表1 = "北京" :: 原列表 // List(北京, 湖北, 浙江)
val 新列表2 = "北京" +: 原列表 // 同上
// 在末尾添加（需要复制整个列表）
val 新列表3 = 原列表 :+ "江苏" // List(湖北, 浙江, 江苏)
// 添加多个元素
val 新列表4 = 原列表 ++ List("江苏", "广东") // List(湖北, 浙江, 江苏, 广东)
println(s"原列表：$原列表") // 保持不变
println(s"新列表：$新列表4") // 新创建的列表
2. 合并列表
val 列表1 = List("湖北", "浙江")
val 列表2 = List("江苏", "广东")
val 列表3 = List("北京", "上海")
// 合并两个列表
val 合并结果1 = 列表1 ::: 列表2 // List(湖北, 浙江, 江苏, 广东)
val 合并结果2 = 列表1 ++ 列表2 // 同上
// 合并多个列表
val 合并结果3 = List.concat(列表1, 列表2, 列表3)
// List(湖北, 浙江, 江苏, 广东, 北京, 上海)
// flatten 展平嵌套列表
val 嵌套列表 = List(列表1, 列表2) // List(List(湖北, 浙江), List(江苏, 广东))
val 展平列表 = 嵌套列表.flatten // List(湖北, 浙江, 江苏, 广东)
3. 其他常用操作（不可变List）
val 省份列表 = List("湖北", "浙江", "江苏", "广东", "北京")
// 访问元素
val 第一个 = 省份列表.head // 湖北
val 除第一个外 = 省份列表.tail // List(浙江, 江苏, 广东, 北京)
val 最后一个 = 省份列表.last // 北京
val 除最后一个外 = 省份列表.init // List(湖北, 浙江, 江苏, 广东)
// 切片
val 前三个 = 省份列表.take(3) // List(湖北, 浙江, 江苏)
val 跳过前两个 = 省份列表.drop(2) // List(江苏, 广东, 北京)
val 切片 = 省份列表.slice(1, 4) // List(浙江, 江苏, 广东)
// 转换
val 大写列表 = 省份列表.map(_.toUpperCase()) // List(湖北, 浙江, 江苏, 广东, 北京)
val 过滤结果 = 省份列表.filter(_.length == 2) // List(湖北, 浙江, 江苏, 广东)
// 排序
val 排序列表 = 省份列表.sorted // 按字母排序
val 自定义排序 = 省份列表.sortWith((a, b) => a.length > b.length) // 按长度降序
（四）综合示例
object ListExample {
def main(args: Array[String]): Unit = {
// 不可变List示例
println("=== 不可变List示例 ===")
val 省份 = List("湖北", "浙江", "江苏")
// 函数式链式调用
val 处理结果 = 省份
.filter(_.contains("江"))
.map(_ + "省")
.sorted
println(s"原列表：$省份")
println(s"处理结果：$处理结果")
// 可变ListBuffer示例
println("\n=== 可变ListBuffer示例 ===")
val 可变省份 = scala.collection.mutable.ListBuffer("湖北", "浙江")
可变省份 += "江苏"
可变省份 ++= List("广东", "福建")
可变省份 -= "浙江"
println(s"最终列表：$可变省份")
// 遍历示例
println("\n=== 遍历示例 ===")
for ((省, 序号) <- 可变省份.zipWithIndex) {
println(s"${序号 + 1}. $省")
}
}
}
