Lambda表达式知识点 请查阅：《【Java 进阶】—— Lambda 表达式》

实现类与接口知识点 请查阅：《【Java 面向对象进阶】—— 抽象与接口》

ArrayList 请查阅：《【Java 常用 API】—— ArrayList》

---

0. 集合体系概述

Java 的集合框架主要分为两大派系，它们分别对应了不同的数据存储需求：

---

0.1 单列集合 (Collection)

• 特点：一次只存储一个元素（对象）。
• 结构：就像图片左侧展示的那样，数据是单独排列的，如“脉劫”、“康师傅”、“粤利粤”。
• 代表接口：
  • List（有序、可重复）
  • Set（无序、不可重复）
• 应用场景：当你只需要把一堆东西装在一起，不需要通过特定的“钥匙”去查找时使用。

---

0.2 双列集合 (Map)

• 特点：一次存储一对元素，即键值对 (Key-Value)。
• 结构：就像图片右侧展示的，数据是成对出现的。左边的“脉劫”对应右边的“5元”。其中，“脉劫”是键（Key），“5元”是值（Value）。
• 代表接口：
  • Map
• 应用场景：当你需要通过一个特定的标识（Key）快速找到对应的数据（Value）时使用，例如字典、身份证查人、商品名查价格。

---

1. Collection集合概述

在正式学习List之前，需要先明确：Collection是单列集合的顶层接口。
像List、Set这类常见单列集合，本质上都共享Collection中定义的一组基础能力。

本文聚焦的重点是：Collection接口本身的共性能力，以及List系列集合的使用与底层理解。

---

2. 数组与集合的区别

数组和集合本质上都是容器，都可以一次性管理多个数据，但它们的侧重点并不相同。

• 相同点：都可以存储多个元素。
• 不同点：
  • 数组长度固定，集合长度可变。
  • 数组既可以存基本数据类型，也可以存引用数据类型。
  • 集合只能存引用数据类型，如果要保存基本类型，需要使用对应的包装类。

例如：【这里涉及包装类的自动装箱机制】

package com.example;
import java.util.ArrayList;
import java.util.Arrays;

public class Demo {
    public static void main(String[] args) {
        // 初始化数组
        int[] arr = {1, 2, 3, 4, 5};
        // 创建 ArrayList
        ArrayList<Integer> list1 = new ArrayList<>();
        // 将数组前 3 个元素添加到 list1
        for (int i = 0; i < 3; i++) {
            list1.add(arr[i]);
        }
        // 打印数组和列表
        System.out.println("arr: " + Arrays.toString(arr));
        System.out.println("list1: " + list1);
    }
}

结论
如果元素个数是固定的，数组足够直接。
如果元素数量会变化，或者希望使用更丰富的操作方法，集合更合适。

---

3. Collection接口的常用方法

Collection中的很多方法会被List和Set系列集合共同继承，因此这一部分属于后续学习的公共基础。

3.1 常用成员方法

方法签名	说明
public boolean add(E e)	添加元素：把给定的对象添加到当前集合中。
public void clear()	清空集合：移除集合中所有的元素，使集合变为空。
public boolean remove(E e)	删除元素：把给定的对象从当前集合中删除（如果存在）。
public boolean contains(Object obj)	判断包含：判断当前集合中是否包含给定的对象。
public boolean isEmpty()	判断为空：检查当前集合中是否没有任何元素。
public int size()	获取长度：返回集合中元素的个数（集合的长度）。

---

3.2 基本使用示例

在开始学习具体方法之前，我们需要明确一点：Collection 是一个接口，我们无法直接实例化它。在实际开发和学习中，通常使用它的实现类（如 ArrayList）来创建对象，并利用多态的特性进行操作。

3.2.1 添加元素 (add)

add(E e) 方法用于将指定的元素添加到集合中。

• 返回值：boolean 类型。
  • 对于 List 系列集合（允许重复），添加通常总是成功，返回 true。
  • 对于 Set 系列集合（不允许重复），如果元素不存在则添加成功返回 true；如果元素已存在则添加失败返回 false。

代码示例：

package com.example;
import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo {
    public static void main(String[] args) {
        // 创建 Collection 集合对象，使用 ArrayList 作为实现类
        Collection<String> coll = new ArrayList<>();
        // 1. 添加元素
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        System.out.println(coll); // 输出: [aaa, bbb, ccc]
    }
}

---

3.2.2 清空集合 (clear)

clear() 方法用于移除集合中所有的元素。执行后，集合变为空集合。

• 返回值：void（无返回值）。

代码示例：

package com.example;
import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo {
    public static void main(String[] args) {
        // 创建 Collection 集合对象，使用 ArrayList 作为实现类
        Collection<String> coll = new ArrayList<>();
        // 1. 添加元素
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        System.out.println(coll);
        // 集合中已有元素 [aaa, bbb, ccc]
        coll.clear();
        System.out.println(coll); // 输出: []
    }
}

---

3.2.3 删除元素 (remove)

remove(E e) 方法用于将指定的对象从集合中删除。

• 返回值：boolean 类型。
  • 如果集合中包含该元素并成功删除，返回 true。
  • 如果集合中不存在该元素，删除失败，返回 false。
• 注意：Collection 接口定义的是共性方法，不支持通过索引删除，只能通过元素对象本身进行删除。

代码示例：

package com.example;
import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo {
    public static void main(String[] args) {
        // 创建 Collection 集合对象，使用 ArrayList 作为实现类
        Collection<String> coll = new ArrayList<>();
        // 1. 添加元素
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        System.out.println(coll);
        // 集合中已有元素 [aaa, bbb, ccc]
        boolean result = coll.remove("aaa");
        System.out.println(result); // 输出: true (表示删除成功)
        System.out.println(coll);   // 输出: [bbb, ccc]
    }
}

---

3.2.4 判断包含 (contains)

contains(Object obj) 方法用于判断当前集合中是否包含指定的对象。

• 底层原理：该方法底层依赖元素的 equals() 方法进行判断。
• 注意事项：
  • 如果集合存储的是字符串或基本数据类型包装类，直接使用即可。
  • 如果集合存储的是自定义对象（如 Student），必须重写 equals() 方法（通常配合 hashCode()），否则默认比较的是对象的内存地址，导致逻辑判断失效。

代码示例：

package com.example;
import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo {
    public static void main(String[] args) {
        // 创建 Collection 集合对象，使用 ArrayList 作为实现类
        Collection<String> coll = new ArrayList<>();
        // 1. 添加元素
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        System.out.println(coll);
        // 集合中已有元素 [aaa, bbb, ccc]
        boolean result = coll.contains("bbb");
        System.out.println(result); // 输出: true
    }
}

3.2.5 判断为空 (isEmpty)

isEmpty() 方法用于检查当前集合中是否没有任何元素。

• 返回值：boolean 类型。
  • 如果集合长度为 0，返回 true。
  • 否则返回 false。

代码示例：

package com.example;
import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo {
    public static void main(String[] args) {
        // 创建 Collection 集合对象，使用 ArrayList 作为实现类
        Collection<String> coll = new ArrayList<>();
        // 1. 添加元素
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        System.out.println(coll);
        //集合中已有元素 [aaa, bbb, ccc]
        boolean result = coll.isEmpty();
        System.out.println(result); // 输出: false
    }
}

3.2.6 获取长度 (size)

size() 方法用于返回集合中元素的个数。

• 返回值：int 类型。

代码示例：

package com.example;
import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo {
    public static void main(String[] args) {
        // 创建 Collection 集合对象，使用 ArrayList 作为实现类
        Collection<String> coll = new ArrayList<>();
        // 1. 添加元素
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        System.out.println(coll);
        // 获取元素个数
        int size = coll.size();
        System.out.println("集合的元素个数为：" + size); // 输出: 3
    }
}

---

3.3 contains 与 remove 的深层原理：自定义对象判等

当集合中存储的是自定义对象（JavaBean）时，contains（判断是否存在）和 remove（删除）方法的准确性完全取决于该对象类中 equals 方法的实现。

3.3.1 问题分析

如果我们直接使用自定义对象，而不重写 equals 方法，集合将默认使用 Object 类中的 equals 方法。Object 类的 equals 方法比较的是对象的内存地址（即 ==）。这意味着，即使两个对象的属性内容完全一样，只要它们是不同的实例（地址不同），集合就会认为它们是不同的对象。

错误示例场景：

Collection<Student> coll = new ArrayList<>();
coll.add(new Student("zhangsan", 23));

// 创建了一个属性相同但地址不同的新对象
Student s4 = new Student("zhangsan", 23); 

// 如果 Student 未重写 equals，结果为 false，因为地址不同
System.out.println(coll.contains(s4)); 

3.3.2 解决方案：重写 equals

为了让集合能够根据对象的属性内容（如姓名和年龄）来判断是否相同，我们需要在 Student 类中重写 equals 方法。

Student 类代码示例：

package com.example;
import java.util.Objects;

public class Student {
    private String name;
    private int age;

    //无参与空参构造
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }
    
    //getter 和 setter 方法
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    //如果没有重写equals方法，比较的是对象的地址
    @Override
    public boolean equals(Object o) {
        // 1. 如果传入对象为空 或 类型不匹配，返回 false
        if (o == null || getClass() != o.getClass()) return false;
        // 2. 强转对象
        Student student = (Student) o;
        // 3. 比较属性：年龄必须相同 且 姓名内容必须相同
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

3.3.3 完整测试代码

package com.example;
import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo {
    public static void main(String[] args) {
        // 1. 创建集合
        Collection<Student> coll = new ArrayList<>();

        // 2. 创建并添加学生对象
        Student s1 = new Student("zhangsan", 23);
        Student s2 = new Student("lisi", 24);
        coll.add(s1);
        coll.add(s2);

        // 3. 创建一个新对象，属性与 s1 相同
        Student s4 = new Student("zhangsan", 23);

        // 4. 判断包含
        // 因为重写了 equals，比较的是属性内容，所以返回 true
        System.out.println(coll.contains(s4)); // 输出: true
    }
}

总结
集合是否“认为两个对象相同”，并不取决于你肉眼看起来像不像，而取决于该类型的判等规则。对于自定义对象，一定要重写 equals 方法（通常也要重写 hashCode）来确保集合功能的正确性。

---

4. Collection集合的遍历

4.1 迭代器遍历

迭代器是集合的专用遍历方式，它不依赖索引，因此适用于更通用的集合遍历。

4.1.1 基本方法

方法名	说明
Iterator<E> iterator()	获取迭代器对象
boolean hasNext()	判断当前位置是否还有元素
E next()	取出当前位置元素，并将指针后移
void remove()	删除迭代器当前指向的元素

4.1.2 示例代码

package com.example;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class IteratorDemo {
    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>();
        coll.add("hello");
        coll.add("world");
        coll.add("java");

        // 获取迭代器
        Iterator<String> it = coll.iterator();
        // 遍历集合
        while (it.hasNext()) {
            String s = it.next();// 获取当前元素,并将指针后移
            System.out.println(s);
        }
    }
}

4.1.3 迭代器删除元素

如果是在遍历过程中删除元素，应优先使用迭代器自己的remove()方法。

package com.example;
import java.util.ArrayList;
import java.util.Iterator;

public class IteratorRemoveDemo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        // 创建迭代器
        Iterator<String> it = list.iterator();
        // 遍历集合，删除元素 "b"
        while (it.hasNext()) {
            String s = it.next();// 获取当前元素,并将指针后移
            if ("b".equals(s)) {
                it.remove();
            }
        }
        System.out.println(list);
    }
}

4.1.4 迭代器的四个细节

• 如果当前位置没有元素还继续next()，会抛出NoSuchElementException。
• 迭代完成后，迭代器指针不会自动复位。
• 一次循环中不要重复调用多次next()。
• 遍历过程中，不要直接调用集合自己的增删方法，否则容易产生并发修改问题。

使用建议
如果你的目标是“边遍历边删除”，请使用迭代器。

---

4.2 增强for遍历

增强for本质上也是对迭代器的语法简化，适合只读遍历。

4.2.1 语法格式

for (元素类型 变量名 : 集合名) {
    // 使用变量
}

4.2.2 示例代码

package com.example;
import java.util.ArrayList;
public class forDemo {
    static void main() {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");

        for (String s : list) {
            System.out.println(s);
        }
    }
}

4.2.3 增强for的细节

增强for中的变量，本质上只是“当前元素的临时副本”。

上面修改的是变量s本身，不会改变集合中原来的元素值。

package com.example;
import java.util.ArrayList;
public class forDemo {
    static void main() {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        // 尝试修改元素（实际不会改变集合）
        for (String s : list) {
            s = "q";
        }
        // 输出集合元素
        for(String sr : list){
            System.out.println(sr);
        }
    }
}

使用建议
如果只是单纯遍历、打印、读取数据，增强for比迭代器更简洁。

---

4.3 Lambda表达式遍历

从 JDK 8 开始，Collection 接口引入了 forEach 默认方法，可以结合 Lambda 表达式实现更简洁、更函数式的遍历方式。

4.3.1 核心语法

集合.forEach(元素 -> 对元素进行的操作)

• 集合：要遍历的 Collection 对象。
• forEach：Collection 接口自带的默认方法。
• 元素：一个参数，代表集合中的每一个元素。
• ->：Lambda 操作符，读作 “goes to”。
• 对元素进行的操作：对每个元素执行的具体代码逻辑。

4.3.2 代码示例

package com.example;

import java.util.ArrayList;
import java.util.Collection;

public class LambdaTraversalDemo {
    public static void main(String[] args) {
        // 1. 创建并填充集合
        Collection<String> coll = new ArrayList<>();
        coll.add("zhangsan");
        coll.add("lisi");
        coll.add("wangwu");

        // 2. 使用 Lambda 表达式遍历集合
        coll.forEach(s -> System.out.println(s));
    }
}

4.3.3 底层原理与演变

Lambda 表达式本质上是对匿名内部类写法的极大简化。

4.3.3.1 匿名内部类写法 (JDK 8 之前)

forEach 方法接收一个 Consumer 接口的实现类对象。我们可以使用匿名内部类来创建这个对象。

    coll.forEach(new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    });

4.3.3.2 Lambda 表达式写法 (JDK 8 及之后)

Lambda 表达式省略了所有样板代码（如 new Consumer<String>()、@Override、方法签名 public void accept），只保留了核心逻辑。

    // Lambda 表达式
    coll.forEach(s -> System.out.println(s));

编译器会自动推断出 s 的类型是 String，并将 Lambda 表达式转换为 Consumer 接口的实例。

4.3.4 适用场景

Lambda 遍历方式非常适合以下场景：

• 只关心遍历结果：你只需要对集合中的每个元素执行某个操作，而不需要关心元素的索引。
• 无需在遍历中修改集合：在 forEach 遍历过程中，不建议对集合本身进行添加或删除元素的操作，这可能会导致 ConcurrentModificationException（并发修改异常）。
• 代码简洁性优先：相比传统的 for 循环或 Iterator，Lambda 写法更加简洁、可读性更强。

---

4.4 三种通用遍历方式如何选择

• 迭代器：遍历过程中需要删除元素时使用。
• 增强for：只是读取数据、打印数据时使用。
• Lambda表达式：代码更简洁，适合轻量遍历。

---

5. List集合

List是Collection的子接口，相比普通的Collection，它最突出的三个特征是：

---

6. List集合的特有方法

由于List拥有索引，因此它比普通Collection多了一批和位置相关的方法。

6.1 特有方法一览

方法签名	功能描述
void add(int index, E element)	插入元素：在列表的指定位置插入指定元素。该位置及之后的元素会向右移动（索引+1）。
E remove(int index)	删除元素：移除列表中指定位置的元素，并将被移除的元素作为返回值返回。
E set(int index, E element)	修改元素：用指定元素替换列表中指定位置的元素，并将原本在该位置的旧元素作为返回值返回。
E get(int index)	获取元素：返回列表中指定位置的元素。这是 List 集合最常用的查询方法。

6.2 示例代码整体一览

package com.example;

import java.util.ArrayList;
import java.util.List;

public class ListMethodDemo {
    public static void main(String[] args) {
        // 创建 ArrayList 并初始化元素
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        System.out.println("原始列表：" + list);
        // 1.add(int index, E element): 在指定位置插入元素
        list.add(1, "java");
        System.out.println("=== add(1, \"java\") ===");
        System.out.println(list);

        // 2.set(int index, E element): 修改指定位置的元素，返回原值
        String oldValue = list.set(2, "mysql");
        System.out.println("\n=== set(2, \"mysql\") ===");
        System.out.println("被替换的元素：" + oldValue);
        System.out.println("替换后的列表：" + list);

        // 3.get(int index): 获取指定位置的元素
        String value = list.get(0);
        System.out.println("\n=== get(0) ===");
        System.out.println("索引 0 的元素：" + value);

        // 4.remove(int index): 删除指定位置的元素，返回被删元素
        String removed = list.remove(1);
        System.out.println("\n=== remove(1) ===");
        System.out.println("被删除的元素：" + removed);
        System.out.println("删除后的列表：" + list);
    }

}

---

7. List集合中的删除陷阱

在List<Integer>集合中，删除操作存在一个极易混淆的场景。由于List接口定义了重载的删除方法，导致在删除数字时容易产生逻辑错误。

7.1 核心问题：到底删的是谁？

List 接口中提供了两个remove方法：

• remove(int index)：根据索引删除（List特有）。
• remove(Object o)：根据元素对象删除（Collection继承）。

7.2 代码演示与分析

请看以下代码，思考 list.remove(1) 到底执行了什么？

package com.example;
import java.util.ArrayList;
import java.util.List;

public class DeleteDemo {
    static void main() {
        List<Integer> list = new ArrayList<>();
        list.add(1); // 索引0
        list.add(2); // 索引1
        list.add(3); // 索引2

        System.out.println("原始列表：" + list);
        // 疑问：此时删除的是数字1，还是索引为1的元素？
        list.remove(1);
        System.out.println("删除后的列表：" + list);
    }
}

结果分析：

• 当你传入直接量 1 时，Java编译器会优先将其视为基本数据类型 int。
• 因此，代码匹配到了 remove(int index) 方法。
• 后果：索引为1的元素（即数字2）被删除，而不是你以为的数字1。

7.3 解决方案：如何删除元素值？

如果你确实想删除元素值1，必须强制让编译器调用 remove(Object o) 方法。这需要将 int 转换为 Integer 对象（装箱）。

修正代码：

package com.example;
import java.util.ArrayList;
import java.util.List;

public class DeleteDemo {
    static void main() {
        List<Integer> list = new ArrayList<>();
        list.add(1); // 索引0
        list.add(2); // 索引1
        list.add(3); // 索引2

        System.out.println("原始列表：" + list);
        // 方案1：手动装箱（推荐，显式且清晰）
        Integer num = Integer.valueOf(1);
        list.remove(num);
        
        //// 方案2：直接传入Integer对象
        //list.remove(Integer.valueOf(1));
        System.out.println("删除后的列表：" + list);
    }
}

⚠️ 避坑指南

• 在 List<Integer> 中，写 remove(1) 默认删的是索引。
• 若要删除元素值，必须进行手动装箱或强转为 (Object) 1。

---

8. List集合的五种遍历方式

• 迭代器：遍历过程中需要删除元素时使用。
• 列表迭代器：遍历过程中需要添加元素时使用。
• 增强for / Lambda：只遍历，不改结构时使用。
• 普通for：需要频繁操作索引时使用。

补充
列表迭代器ListIterator比普通迭代器更强，它不仅能向后遍历，还支持部分场景下的添加操作，甚至可以反向遍历。

8.1 示例代码一览

package com.example;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class ListTraverseDemo {
    public static void main(String[] args) {
        // 创建 ArrayList 并初始化元素
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        // 1. 迭代器遍历
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            System.out.print(it.next()+" ");
        }
        System.out.println();

        // 2. 增强 for 循环遍历
        for (String s : list) {
            System.out.print(s + " ");
        }
        System.out.println();

        // 3. Lambda 表达式遍历
        list.forEach(s -> System.out.print(s+" "));
        System.out.println();

        // 4. 普通 for 循环遍历
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i)+" ");
        }
        System.out.println();

        // 5. 列表迭代器遍历（可添加元素）
        ListIterator<String> lit = list.listIterator();
        while (lit.hasNext()) {
            String str = lit.next();
            //在 bbb 后面添加 qqq
            if ("bbb".equals(str)) {
                lit.add("qqq");
            }
        }
        // 输出最终结果
        System.out.println(list);
    }
}

---

9. 数据结构基础：为什么List有不同实现类

集合不是孤立存在的，它底层依赖数据结构来组织数据。
理解了数据结构，才能真正理解为什么ArrayList和LinkedList各有优缺点。

9.1 栈与队列

9.1.1 栈

• 特点：后进先出，先进后出
• 常见动作：
  • 压栈 / 进栈
  • 弹栈 / 出栈

---

9.1.2 队列

• 特点：先进先出，后进后出
• 一端进入，一端取出。

---

9.2 数组与链表

9.2.1 数组结构

---

9.2.2 链表结构

9.2.2.1 结点

---

9.2.2.2 增删快，查找慢

---

9.2.2.3 单向链表与双向链表

• 双向链表的优势在于：既可以向后找，也可以向前找。

---

10. List集合的常见实现类

10.1 ArrayList

ArrayList底层基于数组实现，因此特点是：

• 查询快
• 增删慢
• 日常开发中使用频率最高

适用场景：

• 查询多，增删少
• 更关注随机访问效率

---

10.2 LinkedList

LinkedList底层基于链表实现，因此特点是：

• 查询慢
• 增删快

适用场景：

• 频繁在头尾或中间插入、删除元素
• 对随机索引访问要求不高

一句话理解
ArrayList更像“好查不好改”，LinkedList更像“好改不好查”。

---

11. LinkedList的特有方法

LinkedList除了拥有List的通用能力之外，还提供了很多直接操作首尾元素的方法。

11.1 常用方法

方法签名	功能描述
void addFirst(E e)	首部插入：将指定元素插入到列表的开头。
void addLast(E e)	尾部追加：将指定元素追加到列表的末尾（等同于 List 接口的 add(e)）。
E getFirst()	获取首元素：返回列表中的第一个元素。如果列表为空，会抛出异常。
E getLast()	获取尾元素：返回列表中的最后一个元素。如果列表为空，会抛出异常。
E removeFirst()	删除首元素：移除并返回列表中的第一个元素。
E removeLast()	删除尾元素：移除并返回列表中的最后一个元素。

11.2 示例代码一览

package com.example;

import java.util.LinkedList;

public class LinkedListDemo {
    public static void main(String[] args) {
        // 1. 创建 LinkedList 集合
        LinkedList<String> list = new LinkedList<>();

        // 初始化基础数据
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        // 此时集合内容: [aaa, bbb, ccc]
        System.out.println("0. 初始集合内容: " + list);
        
        // 2. 演示首尾添加方法 (addFirst, addLast)
        // 在列表开头插入元素
        list.addFirst("start");
        // 在列表末尾追加元素
        list.addLast("end");
        System.out.println("1. 添加首尾元素后: " + list);
        // 预期输出: [start, aaa, bbb, ccc, end]

        System.out.println("-------------------------");
        // 3. 演示首尾获取方法 (getFirst, getLast)
        // 注意：获取方法不会改变集合的长度，只是“看一眼”
        String first = list.getFirst();
        System.out.println("2. 获取第一个元素: " + first);
        // 预期输出: start

        String last = list.getLast();
        System.out.println("3. 获取最后一个元素: " + last);
        // 预期输出: end

        System.out.println("-------------------------");
        // 4. 演示首尾删除方法 (removeFirst, removeLast)
        // 注意：删除方法会将元素从集合中移除，并返回被删除的元素
        String removedFirst = list.removeFirst();
        System.out.println("4. 被删除的第一个元素是: " + removedFirst);
        // 预期输出: start

        String removedLast = list.removeLast();
        System.out.println("5. 被删除的最后一个元素是: " + removedLast);
        // 预期输出: end

        // 查看删除后的最终集合状态
        System.out.println("6. 最终集合内容: " + list);
        // 预期输出: [aaa, bbb, ccc] (回到了最初的状态)
    }
}

---