本文介绍如何通过 java 泛型重构固定类型的链表，使其能安全、高效地存储任意数据类型（如 bufferedimage、integer 等），避免代码重复和类型不安全操作。
本文介绍如何通过 java 泛型重构固定类型的链表，使其能安全、高效地存储任意数据类型（如 bufferedimage、integer 等），避免代码重复和类型不安全操作。
在 Java 中，为每种数据类型（如 BufferedImage、Integer）单独编写一套链表类（Node + LinkedList）不仅违反 DRY 原则，还会导致维护成本剧增、类型转换风险升高，且丧失编译期类型检查能力。真正的高效解法是——使用泛型（Generics），让同一套链表逻辑适配所有类型，同时保障类型安全与运行时性能。
✅ 正确做法：泛型化 Node 与 LinkedList
首先将 Node 类泛型化，用类型参数 <t></t> 替代硬编码的 BufferedImage：
public class Node<T> {
private T data;
private Node<T> link;
public Node<T> getLink() { return link; }
public void setLink(Node<T> link) { this.link = link; }
public T getData() { return data; }
public void setData(T data) { this.data = data; }
}接着泛型化 LinkedList 类，所有方法签名中的 BufferedImage 全部替换为泛型 T，并确保内部节点引用也保持一致：
public class LinkedList<T> {
private Node<T> root;
public Node<T> getRoot() { return root; }
public void add(T data) {
if (root == null) {
root = new Node<>();
root.setData(data);
} else {
Node<T> tmp = root;
while (tmp.getLink() != null) {
tmp = tmp.getLink();
}
Node<T> newNode = new Node<>();
newNode.setData(data);
tmp.setLink(newNode);
}
}
public int size() {
if (root == null) return 0;
int count = 0;
Node<T> tmp = root;
while (tmp != null) {
count++;
tmp = tmp.getLink();
}
return count;
}
public T get(int pos) {
if (pos < 0 || pos >= size()) {
throw new IndexOutOfBoundsException("Index " + pos + " out of bounds.");
}
Node<T> tmp = root;
for (int i = 0; i < pos; i++) tmp = tmp.getLink();
return tmp.getData();
}
public void set(int pos, T data) {
if (pos < 0 || pos >= size()) {
throw new IndexOutOfBoundsException("Index " + pos + " out of bounds.");
}
Node<T> tmp = root;
for (int i = 0; i < pos; i++) tmp = tmp.getLink();
tmp.setData(data);
}
public void delete() {
if (root == null || size() == 1) {
root = null;
return;
}
Node<T> tmp = root;
for (int i = 0; i < size() - 2; i++) {
tmp = tmp.getLink();
}
tmp.setLink(null);
}
}? 注意：
delete()方法原逻辑存在边界缺陷（如空链表或单节点时未处理），已补充健壮性判断；泛型类中无需强制指定类型参数（如new Node<t>()</t>），Java 会自动推导，但声明字段/变量时必须带类型（如Node<t> tmp</t>）。
? 实际使用示例
泛型链表的实例化需在尖括号中明确指定类型，编译器将据此进行类型检查与自动装箱/拆箱：
// 存储 BufferedImage
LinkedList<BufferedImage> imageList = new LinkedList<>();
BufferedImage img = new BufferedImage(100, 100, BufferedImage.TYPE_INT_ARGB);
imageList.add(img);
System.out.println("Image list size: " + imageList.size()); // → 1
// 存储 Integer（自动装箱）
LinkedList<Integer> intList = new LinkedList<>();
intList.add(42); // 等价于 add(Integer.valueOf(42))
intList.add(100);
System.out.println("Integer list size: " + intList.size()); // → 2
// 存储自定义组合对象（推荐关联数据统一管理）
class ImageWithId {
final BufferedImage image;
final int id;
ImageWithId(BufferedImage img, int id) {
this.image = img;
this.id = id;
}
}
LinkedList<ImageWithId> mixedList = new LinkedList<>();
mixedList.add(new ImageWithId(img, 123));⚠️ 重要注意事项与最佳实践
-
不要滥用
Object或原始类型替代泛型：Node<object></object>会丢失类型信息，需手动强转，易引发ClassCastException；泛型在编译期擦除，但提供完整类型约束。 -
关联数据优先封装为 POJO：若
BufferedImage和int在业务上存在逻辑绑定（如“图片ID”），绝不应维护两个独立链表——这极易导致索引错位、同步困难等 bug。应创建ImageMetadata等包装类，用单个泛型链表统一管理。 -
泛型不支持基本类型：
LinkedList<int></int>非法，必须使用包装类Integer、Double等（Java 自动装箱/拆箱）。 - 性能无损耗：泛型是编译期特性，生成的字节码与原始类型链表完全一致，零运行时开销。
通过泛型重构，你获得的不仅是一套可复用的链表实现，更是一种类型安全、易于扩展、符合现代 Java 工程规范的设计范式。从此，一个 LinkedList<t></t> 即可优雅承载万物。
