Java 集合框架完全指南

Java 集合框架完全指南

目录

1. 集合框架概述
2. [Collection 接口](#Collection 接口)
3. [List 列表](#List 列表)
4. [Set 集合](#Set 集合)
5. [Queue 队列](#Queue 队列)
6. [Map 映射](#Map 映射)
7. 迭代器
8. [Collections 工具类](#Collections 工具类)
9. 并发集合
10. 实战案例
11. 最佳实践

---

1. 集合框架概述

1.1 什么是集合框架

Java 集合框架（Java Collections Framework，JCF）是一套用于存储和操作对象集合的统一架构。

1.2 集合框架层次结构

                    Iterable
                       │
                   Collection
          ┌────────────┼────────────┐
         List         Set         Queue
          │            │            │
    ┌─────┼─────┐  ┌───┼───┐   ┌────┼────┐
ArrayList  │  Vector  HashSet │  LinkedList │
    LinkedList    TreeSet  SortedSet  PriorityQueue


                      Map
          ┌────────────┼────────────┐
       HashMap     TreeMap     Hashtable
          │
    LinkedHashMap

1.3 常用实现类对比

接口	实现类	特点
List	ArrayList	动态数组，随机访问快
List	LinkedList	双向链表，插入删除快
Set	HashSet	基于 HashMap，无序
Set	TreeSet	红黑树，有序
Queue	PriorityQueue	优先级堆
Map	HashMap	哈希表，无序
Map	TreeMap	红黑树，按键排序

---

2. Collection 接口

2.1 基本方法

Collection<String> collection = new ArrayList<>();

// 添加元素
collection.add("Apple");
collection.add("Banana");

// 基本查询
collection.size();
collection.isEmpty();
collection.contains("Apple");

// 删除元素
collection.remove("Banana");

// 遍历
for (String item : collection) {
    System.out.println(item);
}
collection.forEach(System.out::println);

// 清空
collection.clear();

2.2 批量操作

Collection<String> c1 = new ArrayList<>(Arrays.asList("A", "B", "C"));
Collection<String> c2 = new ArrayList<>(Arrays.asList("B", "C", "D"));

// 并集
Collection<String> union = new ArrayList<>(c1);
union.addAll(c2);

// 交集
Collection<String> intersection = new ArrayList<>(c1);
intersection.retainAll(c2);

// 差集
Collection<String> difference = new ArrayList<>(c1);
difference.removeAll(c2);

2.3 条件删除（Java 8+）

Collection<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
numbers.removeIf(n -> n % 2 == 0);  // 删除偶数

---

3. List 列表

3.1 ArrayList

List<String> list = new ArrayList<>();

// 基本操作
list.add("Apple");
list.add(0, "Banana");
list.set(0, "Cherry");
String item = list.get(0);
list.remove(0);

// 搜索
int index = list.indexOf("Apple");

// 子列表
List<String> subList = list.subList(0, 2);

3.2 LinkedList

LinkedList<String> list = new LinkedList<>();

// 双端操作
list.addFirst("First");
list.addLast("Last");
list.removeFirst();
list.removeLast();

// 栈操作
list.push("Element");
list.pop();

// 队列操作
list.offer("Element");
list.poll();

3.3 ArrayList vs LinkedList

特性	ArrayList	LinkedList
随机访问	O(1)	O(n)
头部插入/删除	O(n)	O(1)
尾部插入/删除	O(1)	O(1)
适用场景	频繁随机访问	频繁插入删除

---

4. Set 集合

4.1 HashSet

Set<String> set = new HashSet<>();
set.add("Apple");
set.add("Apple");  // 重复元素不会被添加
set.remove("Apple");
boolean contains = set.contains("Apple");

4.2 TreeSet

TreeSet<Integer> numbers = new TreeSet<>();
numbers.addAll(Arrays.asList(5, 3, 7, 1, 9));

// NavigableSet 方法
numbers.lower(5);    // 小于 5 的最大元素
numbers.higher(5);   // 大于 5 的最小元素
numbers.first();     // 最小元素
numbers.last();      // 最大元素

4.3 HashSet vs TreeSet

特性	HashSet	TreeSet
顺序	无序	排序
null	允许	不允许
复杂度	O(1)	O(log n)

---

5. Queue 队列

5.1 ArrayDeque

Deque<String> deque = new ArrayDeque<>();

// 队列操作
deque.offer("A");
deque.poll();

// 栈操作
deque.push("B");
deque.pop();

// 双端操作
deque.addFirst("First");
deque.addLast("Last");

5.2 PriorityQueue

// 最小堆
PriorityQueue<Integer> minHeap = new PriorityQueue<>();
minHeap.offer(3);
minHeap.offer(1);
minHeap.poll();  // 1

// 最大堆
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Comparator.reverseOrder());

---

6. Map 映射

6.1 HashMap

Map<String, Integer> map = new HashMap<>();

// 基本操作
map.put("Apple", 1);
map.get("Apple");
map.getOrDefault("Grape", 0);
map.remove("Apple");
map.containsKey("Apple");

// 遍历
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}
map.forEach((k, v) -> System.out.println(k + ": " + v));

6.2 Java 8+ 新方法

map.putIfAbsent("B", 2);
map.computeIfAbsent("C", k -> k.length());
map.computeIfPresent("A", (k, v) -> v + 1);
map.merge("A", 1, Integer::sum);

6.3 TreeMap

TreeMap<Integer, String> treeMap = new TreeMap<>();
treeMap.put(3, "Three");
treeMap.put(1, "One");

// NavigableMap 方法
treeMap.lowerEntry(2);
treeMap.higherEntry(2);
treeMap.firstEntry();
treeMap.lastEntry();

---

7. 迭代器

7.1 Iterator

List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));

Iterator<String> it = list.iterator();
while (it.hasNext()) {
    String item = it.next();
    if (item.equals("B")) {
        it.remove();  // 安全删除
    }
}

7.2 ListIterator

ListIterator<String> listIt = list.listIterator();

// 双向遍历
while (listIt.hasNext()) {
    listIt.next();
}
while (listIt.hasPrevious()) {
    listIt.previous();
}

// 修改
listIt.set("X");
listIt.add("Y");

---

8. Collections 工具类

8.1 排序和搜索

List<Integer> list = new ArrayList<>(Arrays.asList(3, 1, 4, 1, 5));

Collections.sort(list);
Collections.sort(list, Comparator.reverseOrder());
int index = Collections.binarySearch(list, 4);
Integer max = Collections.max(list);
Integer min = Collections.min(list);

8.2 修改操作

Collections.reverse(list);
Collections.shuffle(list);
Collections.rotate(list, 2);
Collections.swap(list, 0, 1);
Collections.fill(list, 0);

8.3 创建特殊集合

List<String> emptyList = Collections.emptyList();
List<String> singletonList = Collections.singletonList("A");
List<String> nCopies = Collections.nCopies(5, "A");

// 同步包装
List<String> syncList = Collections.synchronizedList(new ArrayList<>());

// 不可变包装
List<String> unmodifiable = Collections.unmodifiableList(list);

---

9. 并发集合

9.1 ConcurrentHashMap

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
map.put("A", 1);
map.putIfAbsent("B", 2);
map.computeIfAbsent("C", k -> k.length());

9.2 CopyOnWriteArrayList

CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
list.add("A");
list.addIfAbsent("B");

9.3 BlockingQueue

BlockingQueue<String> queue = new ArrayBlockingQueue<>(10);
queue.put("A");        // 阻塞直到有空间
queue.take();          // 阻塞直到有元素
queue.offer("B", 1, TimeUnit.SECONDS);  // 超时

---

10. 实战案例

10.1 统计单词频率

public Map<String, Long> countWords(String text) {
    return Arrays.stream(text.toLowerCase().split("\\W+"))
        .filter(word -> !word.isEmpty())
        .collect(Collectors.groupingBy(
            Function.identity(),
            Collectors.counting()
        ));
}

10.2 LRU 缓存

class LRUCache<K, V> extends LinkedHashMap<K, V> {
    private final int maxSize;
    
    public LRUCache(int maxSize) {
        super(16, 0.75f, true);
        this.maxSize = maxSize;
    }
    
    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        return size() > maxSize;
    }
}

10.3 分组统计

Map<String, List<User>> usersByCity = users.stream()
    .collect(Collectors.groupingBy(User::getCity));

Map<String, Long> countByCity = users.stream()
    .collect(Collectors.groupingBy(User::getCity, Collectors.counting()));

---

11. 最佳实践

11.1 选择合适的集合

需求	推荐集合
有序、可重复	ArrayList
频繁插入删除	LinkedList
不重复、无序	HashSet
不重复、有序	TreeSet
键值对、无序	HashMap
键值对、有序	TreeMap
线程安全 Map	ConcurrentHashMap

11.2 编程建议

// ✅ 面向接口编程
List<String> list = new ArrayList<>();
Map<String, Integer> map = new HashMap<>();

// ✅ 指定初始容量
List<String> list = new ArrayList<>(100);
Map<String, Integer> map = new HashMap<>(100);

// ✅ 使用 isEmpty() 而非 size() == 0
if (list.isEmpty()) { }

// ✅ 使用 for-each 或 forEach
for (String item : list) { }
list.forEach(System.out::println);

// ✅ 使用 computeIfAbsent
map.computeIfAbsent(key, k -> new ArrayList<>()).add(value);

---

附录：集合速查表

时间复杂度

操作	ArrayList	LinkedList	HashSet	TreeSet	HashMap	TreeMap
添加	O(1)*	O(1)	O(1)	O(log n)	O(1)	O(log n)
删除	O(n)	O(1)	O(1)	O(log n)	O(1)	O(log n)
查找	O(n)	O(n)	O(1)	O(log n)	O(1)	O(log n)
访问	O(1)	O(n)	-	-	O(1)	O(log n)

*均摊复杂度