Java 集合框架完全指南

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 基本方法

java 复制代码

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 批量操作

java 复制代码

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+）

java 复制代码

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

3. List 列表

3.1 ArrayList

java 复制代码

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

java 复制代码

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

java 复制代码

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

4.2 TreeSet

java 复制代码

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

java 复制代码

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

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

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

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

5.2 PriorityQueue

java 复制代码

// 最小堆
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

java 复制代码

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+ 新方法

java 复制代码

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

java 复制代码

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

java 复制代码

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

java 复制代码

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 排序和搜索

java 复制代码

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 修改操作

java 复制代码

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

8.3 创建特殊集合

java 复制代码

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

java 复制代码

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

9.2 CopyOnWriteArrayList

java 复制代码

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

9.3 BlockingQueue

java 复制代码

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

10. 实战案例

10.1 统计单词频率

java 复制代码

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 缓存

java 复制代码

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 分组统计

java 复制代码

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 编程建议

java 复制代码

// ✅ 面向接口编程
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)

*均摊复杂度

Java 集合框架完全指南

Java 集合框架完全指南

目录

1. 集合框架概述

1.1 什么是集合框架

1.2 集合框架层次结构

1.3 常用实现类对比

2. Collection 接口

2.1 基本方法

2.2 批量操作

2.3 条件删除（Java 8+）

3. List 列表

3.1 ArrayList

3.2 LinkedList

3.3 ArrayList vs LinkedList

4. Set 集合

4.1 HashSet

4.2 TreeSet

4.3 HashSet vs TreeSet

5. Queue 队列

5.1 ArrayDeque

5.2 PriorityQueue

6. Map 映射

6.1 HashMap

6.2 Java 8+ 新方法

6.3 TreeMap

7. 迭代器

7.1 Iterator

7.2 ListIterator

8. Collections 工具类

8.1 排序和搜索

8.2 修改操作

8.3 创建特殊集合

9. 并发集合

9.1 ConcurrentHashMap

9.2 CopyOnWriteArrayList

9.3 BlockingQueue

10. 实战案例

10.1 统计单词频率

10.2 LRU 缓存

10.3 分组统计

11. 最佳实践

11.1 选择合适的集合

11.2 编程建议

附录：集合速查表

时间复杂度