Javajava算法
Java 集合框架进阶——List 实现类深度解析与实战优化
Java 集合框架 List 实现类深度解析与实战优化。文章详细阐述了 ArrayList 动态数组扩容机制、索引访问优势，LinkedList 双向链表增删特性，以及 Vector 线程安全实现。对比遍历效率、内存占用及并发场景表现，提供选择策略与优化技巧，如初始化容量设定、避免并发修改异常。结合学生成绩管理系统实战案例，展示 List 实际应用与注意事项。
Java 集合框架 List 实现类深度解析与实战优化。文章详细阐述了 ArrayList 动态数组扩容机制、索引访问优势，LinkedList 双向链表增删特性，以及 Vector 线程安全实现。对比遍历效率、内存占用及并发场景表现，提供选择策略与优化技巧，如初始化容量设定、避免并发修改异常。结合学生成绩管理系统实战案例，展示 List 实际应用与注意事项。
💡 List 作为 Java 集合框架中最常用的接口之一，继承自 Collection 接口，其核心特性是有序性和可重复性：
// List 接口核心方法示例
public interface List<E> extends Collection<E> {
// 基于索引获取元素
E get(int index);
// 基于索引替换元素
E set(int index, E element);
// 基于索引插入元素
void add(int index, E element);
// 基于索引删除元素
E remove(int index);
// 查找元素首次出现的索引
int indexOf(Object o);
// 查找元素最后出现的索引
int lastIndexOf(Object o);
// 获取 List 迭代器
ListIterator<E> listIterator();
}
⚠️ 注意：List 接口本身是抽象的，无法直接实例化，必须通过其实现类创建对象。Java 中最常用的 List 实现类有三个：ArrayList、LinkedList、Vector，它们各自基于不同的底层数据结构，适用于不同的业务场景。
💡 ArrayList 的底层是动态数组（Object[]），通过数组扩容机制实现容量的动态增长。其核心成员变量如下：
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
// 存储元素的数组
transient Object[] elementData;
// 集合中实际元素的个数
private int size;
// 默认初始容量
private static final int DEFAULT_CAPACITY = 10;
// 空数组（用于空实例）
private static final Object[] EMPTY_ELEMENTDATA = {};
// 默认空数组（用于默认构造函数）
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
}
ArrayList 的 add() 方法有两个重载版本：末尾添加和指定索引添加，核心逻辑是先检查容量，不足则扩容，再添加元素。
public boolean add(E e) {
// 确保容量充足（size + 1）
ensureCapacityInternal(size + 1);
// 元素添加到数组末尾，size 自增
elementData[size++] = e;
return true;
}
// 确保内部容量
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
// 计算所需容量
private static int calculateCapacity(Object[] elementData, int minCapacity) {
// 若为默认空数组，返回默认容量（10）与最小所需容量的最大值
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
// 确保显式容量
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// 记录集合修改次数（用于快速失败机制）
// 若所需容量大于当前数组长度，触发扩容
if (minCapacity - elementData.length > 0) {
grow(minCapacity);
}
}
// 扩容核心方法
private void grow(int minCapacity) {
// 当前数组长度
int oldCapacity = elementData.length;
// 新容量 = 旧容量 + 旧容量/2（即扩容 1.5 倍）
int oldCapacity + (oldCapacity >> );
(newCapacity - minCapacity < ) {
newCapacity = minCapacity;
}
(newCapacity - MAX_ARRAY_SIZE > ) {
newCapacity = hugeCapacity(minCapacity);
}
elementData = Arrays.copyOf(elementData, newCapacity);
}
💡 扩容机制关键点：
oldCapacity >> 1 实现，效率高于除法）Integer.MAX_VALUE - 8，主要是为了避免某些虚拟机在数组头存储额外信息导致的溢出问题public void add(int index, E element) {
// 检查索引是否越界（0 <= index <= size）
rangeCheckForAdd(index);
// 确保容量充足
ensureCapacityInternal(size + 1);
// 复制原数组中 index 及之后的元素，向后移动一位（腾出 index 位置）
System.arraycopy(elementData, index, elementData, index + 1, size - index);
// 在 index 位置插入新元素
elementData[index] = element;
size++;
}
// 索引越界检查
private void rangeCheckForAdd(int index) {
if (index > size || index < 0) {
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
}
⚠️ 注意：指定索引添加元素时，需要移动数组元素，时间复杂度为 O(n)，元素越多，效率越低。因此，ArrayList 不适合频繁在中间位置插入元素的场景。
public E get(int index) {
// 索引越界检查
rangeCheck(index);
// 直接通过数组索引获取元素，时间复杂度 O(1)
return elementData(index);
}
// 索引越界检查
private void rangeCheck(int index) {
if (index >= size) {
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
}
// 转换为泛型类型
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
}
💡 由于 ArrayList 底层是数组，数组支持随机访问，因此 get() 方法直接通过索引获取元素，效率极高，这是 ArrayList 最核心的优势之一。
public E remove(int index) {
// 索引越界检查
rangeCheck(index);
modCount++;
// 获取要删除的元素
E oldValue = elementData(index);
// 计算需要移动的元素个数
int numMoved = size - index - 1;
// 若需要移动元素（删除的不是最后一个元素），则向前移动数组元素
if (numMoved > 0) {
System.arraycopy(elementData, index + 1, elementData, index, numMoved);
}
// 释放最后一个元素的引用（帮助 GC）
elementData[--size] = null;
// 返回被删除的元素
return oldValue;
}
⚠️ 注意：删除非末尾元素时，需要移动数组元素，时间复杂度为 O(n)；同时，ArrayList 删除元素后不会自动收缩数组容量（即 elementData 长度不变），只会减少 size 计数，若需要释放内存，可手动调用 trimToSize() 方法。
// 手动收缩数组容量，释放空闲内存
public void trimToSize() {
modCount++;
if (size < elementData.length) {
elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size);
}
}
| 操作类型 | 时间复杂度 | 说明 |
|---|---|---|
| 末尾添加（add(E e)） | O(1) | 扩容时为 O(n)，但扩容频率低（1.5 倍扩容） |
| 指定索引添加/删除 | O(n) | 需要移动数组元素 |
| 索引访问（get/set） | O(1) | 随机访问，效率极高 |
| 查找元素（indexOf） | O(n) | 需遍历数组 |
💡 技巧 1：初始化时指定初始容量，减少扩容次数
// 推荐：已知元素数量约为 1000，直接指定初始容量
List<String> list = new ArrayList<>(1000);
// 不推荐：无参构造，首次添加元素扩容为 10，后续需多次扩容
List<String> list = new ArrayList<>();
💡 技巧 2：避免在中间位置频繁添加/删除元素，若需频繁修改，考虑使用 LinkedList
💡 技巧 3：遍历 ArrayList 时，优先使用普通 for 循环或增强 for 循环（foreach），效率高于迭代器（Iterator）
// 高效遍历方式
ArrayList<String> list = new ArrayList<>();
// 普通 for 循环（索引访问，O(1)）
for (int i = 0; i < list.size(); i++) {
String element = list.get(i);
}
// 增强 for 循环（底层基于迭代器，但语法简洁，效率接近普通 for 循环）
for (String element : list) {
// 业务逻辑
}
💡 技巧 4：大量数据处理后，若集合不再添加元素，调用 trimToSize() 释放空闲内存
List<LargeObject> list = new ArrayList<>(10000);
// 批量添加大量元素...
list.trimToSize(); // 收缩数组容量，释放未使用的内存
💡 LinkedList 的底层是双向链表，每个节点（Node）包含前驱节点引用、后继节点引用和元素值。其核心成员变量如下：
public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable {
// 链表长度
transient int size = 0;
// 头节点（前驱为 null）
transient Node<E> first;
// 尾节点（后继为 null）
transient Node<E> last;
// 双向链表节点类
private static class Node<E> {
E item; // 元素值
Node<E> next; // 后继节点引用
Node<E> prev; // 前驱节点引用
Node(Node<E> prev, E element, Node<E> next) {
this.prev = prev;
this.item = element;
this.next = next;
}
}
}
双向链表结构示意图：
first（头节点） last（尾节点）
↓ ↓
[prev:null, item:A, next→] ←→ [prev←, item:B, next→] ←→ ... ←→ [prev←, item:Z, next:null]
public boolean add(E e) {
// 调用 linkLast 方法，将元素链接到链表尾部
linkLast(e);
return true;
}
// 链接到链表尾部
void linkLast(E e) {
// 保存当前尾节点
final Node<E> l = last;
// 创建新节点（前驱为当前尾节点，后继为 null）
final Node<E> newNode = new Node<>(l, e, null);
// 更新尾节点为新节点
last = newNode;
// 若原链表为空（l 为 null），则头节点也指向新节点
if (l == null) {
first = newNode;
} else {
// 原尾节点的后继指向新节点
l.next = newNode;
}
// 链表长度自增
size++;
modCount++;
}
💡 末尾添加元素时，只需创建新节点并更新尾节点引用，时间复杂度为 O(1)，无需移动元素，效率极高。
public void add(int index, E element) {
// 检查索引是否越界（0 <= index <= size）
checkPositionIndex(index);
// 若索引等于 size，直接添加到尾部
if (index == size) {
linkLast(element);
} else {
// 找到索引位置的节点，将新节点链接到其前面
linkBefore(element, node(index));
}
}
// 找到指定索引位置的节点
Node<E> node(int index) {
// 优化：根据索引位置判断从头部还是尾部遍历（二分思想）
if (index < (size >> 1)) {
// 索引在前半部分，从头部遍历
Node<E> x = first;
for (int i = 0; i < index; i++) {
x = x.next;
}
return x;
} else {
// 索引在后半部分，从尾部遍历
Node<E> x = last;
for (int i = size - 1; i > index; i--) {
x = x.prev;
}
return x;
}
}
// 将新节点链接到指定节点之前
void linkBefore(E e, Node<E> succ) {
// 保存指定节点的前驱节点
final Node<E> pred = succ.prev;
// 创建新节点（前驱为 pred，后继为 succ）
final Node<E> newNode = new Node<>(pred, e, succ);
// 指定节点的前驱指向新节点
succ.prev = newNode;
// 若 pred 为 null（说明 succ 是头节点），则头节点更新为新节点
if (pred == null) {
first = newNode;
} {
pred.next = newNode;
}
size++;
modCount++;
}
💡 指定索引添加元素的核心逻辑：
public E get(int index) {
// 检查索引是否越界
checkElementIndex(index);
// 调用 node() 方法找到指定索引的节点，返回元素值
return node(index).item;
}
⚠️ 注意：LinkedList 没有数组那样的随机访问能力，get() 方法需要通过 node() 方法遍历链表找到目标节点，时间复杂度为 O(n)，因此索引访问效率远低于 ArrayList。
public E remove(int index) {
// 检查索引是否越界
checkElementIndex(index);
// 找到指定索引的节点，调用 unlink 方法删除
return unlink(node(index));
}
// 删除指定节点
E unlink(Node<E> x) {
// 获取节点的元素值、前驱节点、后继节点
final E element = x.item;
final Node<E> next = x.next;
final Node<E> prev = x.prev;
// 处理前驱节点
if (prev == null) {
// 若前驱为 null，说明 x 是头节点，更新头节点为 next
first = next;
} else {
// 前驱节点的后继指向 next，断开与 x 的连接
prev.next = next;
x.prev = null; // 帮助 GC
}
// 处理后继节点
if (next == null) {
// 若后继为 null，说明 x 是尾节点，更新尾节点为 prev
last = prev;
} else {
// 后继节点的前驱指向 prev，断开与 x 的连接
next.prev = prev;
x.next = null; // 帮助 GC
}
// 清空节点的元素值，帮助 GC
x.item = null;
size--;
modCount++;
return element;
}
💡 删除节点时，仅需修改前后节点的引用，断开与目标节点的连接，时间复杂度为 O(1)（找到目标节点的时间复杂度为 O(n)），因此 LinkedList 适合频繁添加/删除元素的场景。
| 操作类型 | 时间复杂度 | 说明 |
|---|---|---|
| 末尾/头部添加/删除 | O(1) | 直接修改头尾节点引用 |
| 指定索引添加/删除 | O(n) | 遍历找到目标节点（O(n)）+ 修改引用（O(1)） |
| 索引访问（get/set） | O(n) | 需遍历链表 |
| 查找元素（indexOf） | O(n) | 需遍历链表 |
| 特性 | ArrayList | LinkedList |
|---|---|---|
| 底层结构 | 动态数组 | 双向链表 |
| 索引访问效率 | O(1)（高效） | O(n)（低效） |
| 中间位置增删效率 | O(n)（低效，需移动元素） | O(n)（较高效，仅需遍历 + 修改引用） |
| 末尾增删效率 | O(1)（扩容时 O(n)） | O(1)（稳定高效） |
| 内存占用 | 连续内存，可能有空闲空间 | 非连续内存，每个节点额外存储前后引用 |
| 线程安全 | 非线程安全 | 非线程安全 |
| 实现接口 | List、RandomAccess | List、Deque、Queue |
💡 技巧 1：利用 LinkedList 实现双端队列（Deque）功能
// 作为双端队列使用
Deque<String> deque = new LinkedList<>();
deqe.addFirst("A"); // 头部添加
deqe.addLast("B"); // 尾部添加
String first = deque.getFirst(); // 获取头部元素
String last = deque.getLast(); // 获取尾部元素
deqe.removeFirst(); // 删除头部元素
deqe.removeLast(); // 删除尾部元素
💡 技巧 2：遍历 LinkedList 时，优先使用迭代器（Iterator）或增强 for 循环，避免使用普通 for 循环（频繁调用 get() 方法，效率极低）
LinkedList<String> list = new LinkedList<>();
// 推荐：增强 for 循环（底层基于迭代器，效率高）
for (String element : list) {
// 业务逻辑
}
// 推荐：迭代器遍历
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String element = iterator.next();
// 业务逻辑
}
// 不推荐：普通 for 循环（每次 get(i) 都要遍历链表）
for (int i = 0; i < list.size(); i++) {
String element = list.get(i); // 效率极低，O(n²) 时间复杂度
}
💡 Vector 是 Java 早期提供的 List 实现类，底层同样是动态数组（Object[]），与 ArrayList 结构相似，但核心区别是线程安全——Vector 的所有核心方法都被 synchronized 关键字修饰，确保多线程环境下的操作原子性。
public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
// 存储元素的数组
protected Object[] elementData;
// 集合中实际元素的个数
protected int elementCount;
// 扩容增量（默认 0）
protected int capacityIncrement;
// 默认初始容量
private static final int DEFAULT_CAPACITY = 10;
}
Vector 的核心方法（add、get、remove 等）都添加了 synchronized 修饰，例如：
// Vector 的 add 方法（线程安全）
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
// Vector 的 get 方法（线程安全）
public synchronized E get(int index) {
if (index >= elementCount) {
throw new ArrayIndexOutOfBoundsException(index);
}
return elementData(index);
}
而 ArrayList 的方法没有 synchronized 修饰，是非线程安全的，多线程环境下并发修改可能导致 ConcurrentModificationException。
Vector 的扩容机制与 ArrayList 不同，主要体现在扩容增量上：
private void grow(int minCapacity) {
// 当前数组长度
int oldCapacity = elementData.length;
// 新容量 = 旧容量 + （扩容增量 > 0 ? 扩容增量 : 旧容量）
int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement : oldCapacity);
// 若新容量仍小于所需容量，直接使用所需容量
if (newCapacity - minCapacity < 0) {
newCapacity = minCapacity;
}
// 检查是否超过最大容量限制
if (newCapacity - MAX_ARRAY_SIZE > 0) {
newCapacity = hugeCapacity(minCapacity);
}
// 复制原数组元素到新数组
elementData = Arrays.copyOf(elementData, newCapacity);
}
Vector 提供了三个构造函数，支持指定初始容量和扩容增量：
// 无参构造：默认初始容量 10，扩容增量 0
public Vector() {
this(DEFAULT_CAPACITY, 0);
}
// 指定初始容量，扩容增量 0
public Vector(int initialCapacity) {
this(initialCapacity, 0);
}
// 指定初始容量和扩容增量
public Vector(int initialCapacity, int capacityIncrement) {
super();
if (initialCapacity < 0) {
throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
}
this.elementData = new Object[initialCapacity];
this.capacityIncrement = capacityIncrement;
}
⚠️ 注意 1：Vector 的线程安全是通过 synchronized 修饰方法实现的，属于粗粒度锁，并发性能较低。若需要更高的并发性能，推荐使用 Collections.synchronizedList(new ArrayList<>()) 或 CopyOnWriteArrayList（JUC 提供的线程安全 List）。
// 方案 1：Collections.synchronizedList（线程安全，并发性能优于 Vector）
List<String> syncList = Collections.synchronizedList(new ArrayList<>());
// 方案 2：CopyOnWriteArrayList（读写分离，适合读多写少场景）
List<String> cowList = new CopyOnWriteArrayList<>();
⚠️ 注意 2：Vector 与 ArrayList 相比，除了线程安全外，其他性能（如索引访问、扩容效率）基本一致，但由于 synchronized 的开销，单线程环境下不推荐使用 Vector，优先选择 ArrayList。
⚠️ 注意 3：Vector 的扩容增量若设置不当，可能导致内存浪费。例如，未指定扩容增量时，每次扩容为 2 倍，若元素数量增长缓慢，会产生大量空闲内存。
多线程环境下修改 List（如一边遍历一边添加/删除元素），或单线程环境下使用迭代器遍历 List 时修改 List，会抛出 ConcurrentModificationException。
// 单线程环境下的并发修改异常示例
List<String> list = new ArrayList<>();
list.add("A");
list.add("B");
// 使用迭代器遍历
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String element = iterator.next();
if (element.equals("A")) {
list.remove(element); // 直接修改 List，触发异常
}
}
List 的迭代器（Iterator）是快速失败（fail-fast）的，迭代器创建时会记录 List 的修改次数（modCount）。遍历过程中，若 List 的修改次数（modCount）与迭代器记录的修改次数（expectedModCount）不一致，会立即抛出异常，防止迭代器继续遍历不一致的数据。
💡 方案 1：使用迭代器的 remove() 方法修改 List
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String element = iterator.next();
if (element.equals("A")) {
iterator.remove(); // 迭代器内部会同步 modCount 和 expectedModCount
}
}
💡 方案 2：使用增强 for 循环遍历（底层基于迭代器，但不支持在遍历中修改，需结合方案 1）
💡 方案 3：多线程环境下使用线程安全的 List（如 CopyOnWriteArrayList）
List<String> list = new CopyOnWriteArrayList<>();
list.add("A");
list.add("B");
// 多线程遍历并修改
new Thread(() -> {
for (String element : list) {
System.out.println(element);
}
}).start();
new Thread(() -> {
list.remove("A");
}).start();
List 常见的遍历方式有 4 种：普通 for 循环、增强 for 循环、迭代器遍历、forEach 方法（Java 8+）。
// 测试代码：遍历 100 万条数据的 ArrayList 和 LinkedList
public class ListTraversalTest {
public static void main(String[] args) {
// 初始化 ArrayList（100 万条数据）
List<Integer> arrayList = new ArrayList<>(1000000);
for (int i = 0; i < 1000000; i++) {
arrayList.add(i);
}
// 初始化 LinkedList（100 万条数据）
List<Integer> linkedList = new LinkedList<>();
for (int i = 0; i < 1000000; i++) {
linkedList.add(i);
}
// 测试 ArrayList 遍历效率
System.out.println("ArrayList 遍历效率测试：");
testTraversal(arrayList);
// 测试 LinkedList 遍历效率
System.out.println("\nLinkedList 遍历效率测试：");
testTraversal(linkedList);
}
private static void testTraversal(List<Integer> list) {
long start, end;
// 1. 普通 for 循环
start = System.currentTimeMillis();
for (int i = 0; i < list.size(); i++) {
list.get(i);
}
end = System.currentTimeMillis();
System.out.println("普通 for 循环：" + (end - start) + );
start = System.currentTimeMillis();
( num : list) {
}
end = System.currentTimeMillis();
System.out.println( + (end - start) + );
start = System.currentTimeMillis();
Iterator<Integer> iterator = list.iterator();
(iterator.hasNext()) {
iterator.next();
}
end = System.currentTimeMillis();
System.out.println( + (end - start) + );
start = System.currentTimeMillis();
list.forEach(num -> {
});
end = System.currentTimeMillis();
System.out.println( + (end - start) + );
}
}
✅ 测试结果（参考值）：
| 遍历方式 | ArrayList（100 万条） | LinkedList（100 万条） |
|---|---|---|
| 普通 for 循环 | 1ms | 8923ms（极差） |
| 增强 for 循环 | 3ms | 4ms |
| 迭代器遍历 | 2ms | 3ms |
| forEach 方法 | 4ms | 5ms |
✅ 结论：
无论是 ArrayList 还是 Vector，初始化时指定合理的初始容量，都能减少扩容次数，降低内存拷贝开销。
对于存储大量对象的 List，不再使用的元素应及时移除（remove() 方法），避免对象引用无法释放，导致内存泄漏。
ArrayList 和 Vector 都提供了 trimToSize() 方法，可将数组容量收缩为实际元素个数，释放未使用的空闲内存，适用于大量数据处理后不再添加元素的场景。
LinkedList 每个节点额外存储 prev 和 next 引用，内存占用比 ArrayList 高，对于大量数据存储，优先选择 ArrayList。
设计一个学生成绩管理系统，支持以下功能：
/**
* 学生成绩实体类
*/
public class StudentScore {
private String studentId; // 学号
private String studentName; // 姓名
private String subject; // 科目
private int score; // 成绩
// 构造函数
public StudentScore(String studentId, String studentName, String subject, int score) {
this.studentId = studentId;
this.studentName = studentName;
this.subject = subject;
// 成绩合法性校验
if (score < 0 || score > 100) {
throw new IllegalArgumentException("成绩必须在 0-100 之间");
}
this.score = score;
}
// getter 和 setter 方法
public String getStudentId() { return studentId; }
public void setStudentId(String studentId) { this.studentId = studentId; }
public String getStudentName() { return studentName; }
public void setStudentName(String studentName) { this.studentName = studentName; }
String { subject; }
{ .subject = subject; }
{ score; }
{
(score < || score > ) {
();
}
.score = score;
}
String {
+
+ studentId + +
+ studentName + +
+ subject + +
+ score + ;
}
}
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
/**
* 成绩管理工具类
*/
public class ScoreManager {
// 存储所有学生成绩（使用 ArrayList，支持高效查询和修改）
private List<StudentScore> scoreList = new ArrayList<>();
/**
* 添加学生成绩
* @param score 学生成绩对象
*/
public void addScore(StudentScore score) {
if (score == null) {
throw new IllegalArgumentException("成绩对象不能为空");
}
scoreList.add(score);
System.out.println("添加成功：" + score);
}
/**
* 根据学号查询学生所有成绩
* @param studentId 学号
* @return 该学生的所有成绩列表
*/
public List<StudentScore> queryScoresByStudentId(String studentId) {
if (studentId == null || studentId.trim().isEmpty()) {
throw new IllegalArgumentException("学号不能为空");
}
// 使用 Stream 过滤，简洁高效
return scoreList.stream()
.filter(score -> studentId.equals(score.getStudentId()))
.collect(Collectors.toList());
}
/**
* 根据科目查询所有学生成绩
* @param subject 科目
* @return 该科目的所有成绩列表
*/
public List<StudentScore> queryScoresBySubject {
(subject == || subject.trim().isEmpty()) {
();
}
scoreList.stream()
.filter(score -> subject.equals(score.getSubject()))
.collect(Collectors.toList());
}
{
(studentId == || studentId.trim().isEmpty()) {
();
}
(subject == || subject.trim().isEmpty()) {
();
}
(newScore < || newScore > ) {
();
}
(StudentScore score : scoreList) {
(studentId.equals(score.getStudentId()) && subject.equals(score.getSubject())) {
score.setScore(newScore);
System.out.println( + studentId + + subject + + newScore);
;
}
}
System.out.println( + studentId + + subject + );
;
}
{
(studentId == || studentId.trim().isEmpty()) {
();
}
(subject == || subject.trim().isEmpty()) {
();
}
( ; i < scoreList.size(); i++) {
scoreList.get(i);
(studentId.equals(score.getStudentId()) && subject.equals(score.getSubject())) {
scoreList.remove(i);
System.out.println( + studentId + + subject);
;
}
}
System.out.println( + studentId + + subject + );
;
}
[] statSubjectScores(String subject) {
(subject == || subject.trim().isEmpty()) {
();
}
List<StudentScore> subjectScores = queryScoresBySubject(subject);
(subjectScores.isEmpty()) {
System.out.println( + subject + );
;
}
;
Integer.MIN_VALUE;
Integer.MAX_VALUE;
(StudentScore score : subjectScores) {
score.getScore();
total += s;
(s > max) {
max = s;
}
(s < min) {
min = s;
}
}
() total / subjectScores.size();
[] result = [];
result[] = average;
result[] = max;
result[] = min;
System.out.println( + subject + );
System.out.printf(, average, max, min);
result;
}
List<StudentScore> {
<>(scoreList);
}
}
/**
* 成绩管理系统测试类
*/
public class ScoreManagerTest {
public static void main(String[] args) {
ScoreManager scoreManager = new ScoreManager();
// 1. 添加学生成绩
System.out.println("=== 1. 添加学生成绩 ===");
scoreManager.addScore(new StudentScore("001", "张三", "Java", 90));
scoreManager.addScore(new StudentScore("001", "张三", "MySQL", 85));
scoreManager.addScore(new StudentScore("002", "李四", "Java", 95));
scoreManager.addScore(new StudentScore("002", "李四", "MySQL", 88));
scoreManager.addScore(new StudentScore("003", "王五", "Java", 80));
System.out.println();
// 2. 根据学号查询成绩
System.out.println("=== 2. 根据学号查询成绩（学号=001） ===");
List<StudentScore> zhangSanScores = scoreManager.queryScoresByStudentId("001");
zhangSanScores.forEach(System.out::println);
System.out.println();
System.out.println();
List<StudentScore> javaScores = scoreManager.queryScoresBySubject();
javaScores.forEach(System.out::println);
System.out.println();
System.out.println();
scoreManager.updateScore(, , );
System.out.println();
System.out.println();
scoreManager.deleteScore(, );
System.out.println();
System.out.println();
scoreManager.statSubjectScores();
System.out.println();
System.out.println();
scoreManager.getAllScores().forEach(System.out::println);
}
}
✅ 本案例基于 ArrayList 实现了学生成绩管理系统，充分利用了 ArrayList 索引访问高效、修改便捷的优势，同时解决了 List 使用过程中的常见问题：
✅ 若系统需要支持频繁添加/删除成绩记录，可将 ArrayList 替换为 LinkedList，但需注意遍历方式的选择（避免普通 for 循环）；若系统需要在多线程环境下运行，可将 ArrayList 替换为 CopyOnWriteArrayList，确保线程安全。
本章深入解析了 Java 集合框架中三大 List 实现类（ArrayList、LinkedList、Vector）的底层数据结构、核心方法源码、性能特点及适用场景，通过实战案例展示了 List 的实际应用，同时总结了 List 使用过程中的常见问题与优化技巧。
核心要点回顾：
通过本章学习，读者应能根据实际业务场景灵活选择 List 实现类，并进行针对性优化，提升 Java 程序的性能和稳定性。下一章将深入学习 Java 集合框架中的 Set 接口及其实现类。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online