Java集合框架初识

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

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

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

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

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

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

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

二、集合框架全景图

 

三、List接口：有序列表

1. ArrayList：动态数组

特点：

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

// 创建ArrayList
List 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 numbers = new LinkedList<>();

// 添加元素
numbers.add(10);
numbers.addFirst(5);  // 头部添加
numbers.addLast(15);  // 尾部添加

// 访问
int first = numbers.getFirst(); // 5

// 删除
numbers.removeFirst(); // 删除5

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

替代方案：

// 使用Collections工具类
List syncList = Collections.synchronizedList(new ArrayList<>());

// 或使用CopyOnWriteArrayList（读多写少场景）
List safeList = new CopyOnWriteArrayList<>();

四、Set接口：唯一集合

1. HashSet：基于哈希表

特点：

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

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

  五、Queue接口：队列

  1. LinkedList：多面手队列

Queue queue = new LinkedList<>();

// 入队
queue.offer("Task1");
queue.offer("Task2");

// 出队
String task = queue.poll(); // "Task1"

// 查看队首
String next = queue.peek(); // "Task2"

2. PriorityQueue：优先级队列

特点：

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

• // 创建优先级队列（最小堆）
  Queue 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 maxHeap = new PriorityQueue<>(Comparator.reverseOrder());
  maxHeap.offer(10);
  maxHeap.offer(5);
  maxHeap.offer(15);
  
  System.out.println(maxHeap.poll()); // 15
  

  3. ArrayDeque：高效双端队列

  特点：

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

Deque 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 scores = new HashMap<>();

// 添加键值对
scores.put("Alice", 90);
scores.put("Bob", 85);
scores.put("Charlie", 95);

// 获取值
int aliceScore = scores.get("Alice"); // 90

// 遍历
for (Map.Entry entry : scores.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

// 检查键是否存在
boolean hasBob = scores.containsKey("Bob"); // true

2. LinkedHashMap：保持插入顺序

Map 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 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 subMap = ((TreeMap) sortedScores)
                            .subMap("A", "C"); // {Alice=90, Bob=85}

七、集合工具类：Collections

  常用工具方法

List 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 immutable = Collections.unmodifiableList(new ArrayList<>());

八、集合框架高级特性

1. 迭代器（Iterator）

List colors = Arrays.asList("Red", "Green", "Blue");

// 使用迭代器遍历
Iterator it = colors.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

// 删除元素
Iterator it2 = colors.iterator();
while (it2.hasNext()) {
    if (it2.next().equals("Green")) {
        it2.remove(); // 安全删除
    }
}

2. 泛型（Generics）

// 定义泛型类
class Box {
    private T content;
    
    public void setContent(T content) {
        this.content = content;
    }
    
    public T getContent() {
        return content;
    }
}

// 使用
Box stringBox = new Box<>();
stringBox.setContent("Hello");

Box intBox = new Box<>();
intBox.setContent(100);

3. 比较器（Comparator）

List 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() {
    @Override
    public 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

常见问题解答

1. ArrayList和LinkedList如何选择？

• 需要随机访问：ArrayList
• 需要频繁增删：LinkedList
• 大多数情况：ArrayList（更优的内存局部性）

2. HashMap和Hashtable的区别？

特性	HashMap	Hashtable
线程安全	否	是
性能	高	低
null键	允许	不允许
迭代器	fail-fast	fail-safe

3. ConcurrentHashMap如何实现线程安全？

• JDK1.7：分段锁（Segment）
• JDK1.8+：CAS + synchronized

总结：集合框架核心要点

1. List：有序可重复 → ArrayList/LinkedList
2. Set：无序唯一 → HashSet/LinkedHashSet/TreeSet
3. Queue：FIFO/LIFO → LinkedList/PriorityQueue/ArrayDeque
4. Map：键值对 → HashMap/LinkedHashMap/TreeMap
5. 工具类：Collections/Arrays
6. 并发集合：ConcurrentHashMap/CopyOnWriteArrayList