当前位置：首页 > news >正文

Java集合框架初识

news 来源：原创 2025/6/22 20:39:47

一、集合框架概述：为什么需要集合？

想象你正在管理一个班级的学生信息：

学生名单（有序列表）
学生成绩（键值对）
不重复的学号（唯一集合）
待批改的作业（队列）

如果用基本数据类型表示：

// 混乱的管理方式
String[] names = new String[50]; // 学生姓名
int[] scores = new int[50];      // 学生成绩
// 添加学生 删除学生 查找学生

集合框架就是为解决这类问题而生的工具箱，它提供：

动态大小的容器
丰富的数据结构
高效的操作方法
统一的API接口

二、集合框架全景图

三、List接口：有序列表

1. ArrayList：动态数组

特点：

底层基于数组
随机访问快（O(1)）
增删慢（需要移动元素）

// 创建ArrayList
List<String> fruits = new ArrayList<>();// 添加元素
fruits.add("Apple");
fruits.add("Banana");
fruits.add(1, "Orange"); // 在索引1插入// 访问元素
String first = fruits.get(0); // "Apple"// 遍历
for (String fruit : fruits) {System.out.println(fruit);
}// 删除元素
fruits.remove("Banana");
fruits.remove(0);

2. LinkedList：双向链表

特点：

底层基于链表
增删快（O(1)）
随机访问慢（O(n)）
实现了Deque接口（双端队列）

// 创建LinkedList
List<Integer> numbers = new LinkedList<>();// 添加元素
numbers.add(10);
numbers.addFirst(5);  // 头部添加
numbers.addLast(15);  // 尾部添加// 访问
int first = numbers.getFirst(); // 5// 删除
numbers.removeFirst(); // 删除5

3. Vector：线程安全的动态数组（已过时）

替代方案：

// 使用Collections工具类
List<String> syncList = Collections.synchronizedList(new ArrayList<>());// 或使用CopyOnWriteArrayList（读多写少场景）
List<String> safeList = new CopyOnWriteArrayList<>();

四、Set接口：唯一集合

1. HashSet：基于哈希表

特点：

无序存储
不允许重复
允许null元素
查找快（O(1)）

Set<String> ids = new HashSet<>();// 添加元素
ids.add("A001");
ids.add("A002");
ids.add("A001"); // 重复，不会被添加System.out.println(ids); // [A001, A002] 顺序不确定// 检查存在
boolean exists = ids.contains("A001"); // true

2. LinkedHashSet：保持插入顺序

特点：

继承HashSet
维护插入顺序
略慢于HashSet

Set<String> orderedSet = new LinkedHashSet<>();
orderedSet.add("First");
orderedSet.add("Second");
orderedSet.add("Third");System.out.println(orderedSet); // [First, Second, Third]

3. TreeSet：基于红黑树

特点：

元素自动排序
不允许null
操作复杂度O(log n)

Set<Integer> sortedNumbers = new TreeSet<>();
sortedNumbers.add(5);
sortedNumbers.add(2);
sortedNumbers.add(8);System.out.println(sortedNumbers); // [2, 5, 8]// 获取范围
Set<Integer> subset = ((TreeSet<Integer>) sortedNumbers).subSet(3, 7); // [5]

五、Queue接口：队列

1. LinkedList：多面手队列

Queue<String> queue = new LinkedList<>();// 入队
queue.offer("Task1");
queue.offer("Task2");// 出队
String task = queue.poll(); // "Task1"// 查看队首
String next = queue.peek(); // "Task2"

2. PriorityQueue：优先级队列

特点：

元素按优先级排序
默认自然顺序
可自定义Comparator

// 创建优先级队列（最小堆）
Queue<Integer> pq = new PriorityQueue<>();
pq.offer(10);
pq.offer(5);
pq.offer(15);System.out.println(pq.poll()); // 5
System.out.println(pq.poll()); // 10// 自定义排序（最大堆）
Queue<Integer> maxHeap = new PriorityQueue<>(Comparator.reverseOrder());
maxHeap.offer(10);
maxHeap.offer(5);
maxHeap.offer(15);System.out.println(maxHeap.poll()); // 15

3. ArrayDeque：高效双端队列

特点：

基于循环数组
比LinkedList更高效
可用作栈或队列

Deque<String> deque = new ArrayDeque<>();// 栈操作
deque.push("First");
deque.push("Second");
System.out.println(deque.pop()); // "Second"// 队列操作
deque.offerLast("Third");
System.out.println(deque.pollFirst()); // "First"

六、Map接口：键值对映射

1. HashMap：基于哈希表

特点：

键唯一
无序存储
允许null键值
查找快（O(1)）

Map<String, Integer> scores = new HashMap<>();// 添加键值对
scores.put("Alice", 90);
scores.put("Bob", 85);
scores.put("Charlie", 95);// 获取值
int aliceScore = scores.get("Alice"); // 90// 遍历
for (Map.Entry<String, Integer> entry : scores.entrySet()) {System.out.println(entry.getKey() + ": " + entry.getValue());
}// 检查键是否存在
boolean hasBob = scores.containsKey("Bob"); // true

2. LinkedHashMap：保持插入顺序

Map<String, Integer> orderedScores = new LinkedHashMap<>();
orderedScores.put("Alice", 90);
orderedScores.put("Bob", 85);
orderedScores.put("Charlie", 95);System.out.println(orderedScores); // {Alice=90, Bob=85, Charlie=95}

3. TreeMap：基于红黑树

特点：

按键排序
操作复杂度O(log n)
提供范围查询

Map<String, Integer> sortedScores = new TreeMap<>();
sortedScores.put("Bob", 85);
sortedScores.put("Alice", 90);
sortedScores.put("Charlie", 95);System.out.println(sortedScores); // {Alice=90, Bob=85, Charlie=95}// 获取子映射
Map<String, Integer> subMap = ((TreeMap<String, Integer>) sortedScores).subMap("A", "C"); // {Alice=90, Bob=85}

七、集合工具类：Collections

常用工具方法

List<Integer> numbers = Arrays.asList(5, 2, 8, 1);// 排序
Collections.sort(numbers); // [1, 2, 5, 8]// 二分查找
int index = Collections.binarySearch(numbers, 5); // 2// 反转
Collections.reverse(numbers); // [8, 5, 2, 1]// 洗牌
Collections.shuffle(numbers); // 随机顺序// 创建不可变集合
List<String> immutable = Collections.unmodifiableList(new ArrayList<>());

八、集合框架高级特性

1. 迭代器（Iterator）

List<String> colors = Arrays.asList("Red", "Green", "Blue");// 使用迭代器遍历
Iterator<String> it = colors.iterator();
while (it.hasNext()) {System.out.println(it.next());
}// 删除元素
Iterator<String> it2 = colors.iterator();
while (it2.hasNext()) {if (it2.next().equals("Green")) {it2.remove(); // 安全删除}
}

2. 泛型（Generics）

// 定义泛型类
class Box<T> {private T content;public void setContent(T content) {this.content = content;}public T getContent() {return content;}
}// 使用
Box<String> stringBox = new Box<>();
stringBox.setContent("Hello");Box<Integer> intBox = new Box<>();
intBox.setContent(100);

3. 比较器（Comparator）

List<Student> students = new ArrayList<>();
students.add(new Student("Alice", 90));
students.add(new Student("Bob", 85));
students.add(new Student("Charlie", 95));// 按分数降序排序
Collections.sort(students, new Comparator<Student>() {@Overridepublic int compare(Student s1, Student s2) {return s2.getScore() - s1.getScore();}
});// Lambda简化
Collections.sort(students, (s1, s2) -> s2.getScore() - s1.getScore());

最佳实践与性能优化

1. 集合选择指南

需求	推荐实现
快速随机访问	ArrayList
频繁增删	LinkedList
去重	HashSet
有序去重	LinkedHashSet
排序	TreeSet
键值对存储	HashMap
有序键值对	LinkedHashMap
排序键值对	TreeMap
高并发	ConcurrentHashMap