Java 集合框架详解

全面掌握 List、Set、Map 等核心数据结构的使用与性能特点

2026-04-09 约 431 字预计阅读 3 分钟

概述

Java 集合框架（Java Collections Framework）是 Java 提供的一套用于存储和操作一组数据的类和接口。它是 Java 编程中最常用的工具之一。

集合体系结构

Collection
├── List（有序、可重复）
│   ├── ArrayList
│   ├── LinkedList
│   └── Vector
│       └── Stack
├── Set（无序、不可重复）
│   ├── HashSet
│   │   └── LinkedHashSet
│   └── TreeSet
└── Queue（队列）
    ├── LinkedList
    ├── PriorityQueue
    └── Deque
        ├── ArrayDeque
        └── LinkedList

Map（键值对）
├── HashMap
│   └── LinkedHashMap
├── TreeMap
├── Hashtable
│   └── Properties
└── ConcurrentHashMap

List 详解

ArrayList vs LinkedList

ArrayList

基于动态数组实现，查询快、插入删除慢。

// 创建 ArrayList
List<String> list = new ArrayList<>();

// 添加元素
list.add("Java");
list.add("Python");
list.add("Go");

// 获取元素
String first = list.get(0); // Java

// 遍历
for (String lang : list) {
    System.out.println(lang);
}

// 使用 Lambda 遍历
list.forEach(System.out::println);

LinkedList

基于双向链表实现，插入删除快、查询慢。

LinkedList<String> linkedList = new LinkedList<>();
linkedList.addFirst("First");
linkedList.addLast("Last");
linkedList.removeFirst();

Set 详解

HashSet

基于 HashMap 实现，无序、不重复。

Set<Integer> set = new HashSet<>();
set.add(1);
set.add(2);
set.add(1); // 重复，不会被添加
System.out.println(set.size()); // 2

TreeSet

基于红黑树实现，有序、不重复。

TreeSet<Integer> treeSet = new TreeSet<>();
treeSet.add(3);
treeSet.add(1);
treeSet.add(2);
// 自动排序: 1, 2, 3

Map 详解

HashMap

最常用的 Map 实现，非线程安全。

Map<String, Integer> map = new HashMap<>();
map.put("Alice", 25);
map.put("Bob", 30);

// 获取值
Integer age = map.get("Alice"); // 25

// 遍历
map.forEach((key, value) -> {
    System.out.println(key + ": " + value);
});

// 获取默认值
Integer charlie = map.getOrDefault("Charlie", 0);

ConcurrentHashMap

线程安全的 Map 实现，性能优于 Hashtable。

ConcurrentHashMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();
concurrentMap.put("key", 1);
concurrentMap.computeIfAbsent("key2", k -> 2);

集合工具类

Collections

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

// 排序
Collections.sort(list); // [1, 1, 3, 4, 5]

// 反转
Collections.reverse(list); // [5, 4, 3, 1, 1]

// 最大/最小值
Integer max = Collections.max(list);
Integer min = Collections.min(list);

// 不可变集合
List<Integer> unmodifiableList = Collections.unmodifiableList(list);

// 线程安全包装
List<Integer> synchronizedList = Collections.synchronizedList(list);

常用操作

集合转换

// List 转 Set
List<String> list = Arrays.asList("a", "b", "a");
Set<String> set = new HashSet<>(list);

// Set 转 List
List<String> newList = new ArrayList<>(set);

// 数组转 List
String[] array = {"a", "b", "c"};
List<String> listFromArray = Arrays.asList(array);

// List 转数组
String[] newArray = list.toArray(new String[0]);

Stream API 操作

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// 过滤偶数
List<Integer> evens = numbers.stream()
    .filter(n -> n % 2 == 0)
    .collect(Collectors.toList());

// 映射平方
List<Integer> squares = numbers.stream()
    .map(n -> n * n)
    .collect(Collectors.toList());

// 求和
int sum = numbers.stream()
    .mapToInt(Integer::intValue)
    .sum();

// 分组
Map<String, List<Integer>> groups = numbers.stream()
    .collect(Collectors.groupingBy(n -> n % 2 == 0 ? "偶数" : "奇数"));

性能比较

集合类型	查询	插入	删除	特点
ArrayList	O(1)	O(n)	O(n)	随机访问快
LinkedList	O(n)	O(1)	O(1)	顺序访问、插入删除快
HashSet/HashMap	O(1)	O(1)	O(1)	无序、去重/键值对
TreeSet/TreeMap	O(log n)	O(log n)	O(log n)	有序
ConcurrentHashMap	O(1)	O(1)	O(1)	线程安全

最佳实践

选择合适的集合：根据操作类型选择（查询多选 ArrayList，插入删除多选 LinkedList）
预估容量：ArrayList 和 HashMap 初始化时指定容量，避免扩容开销
使用泛型：确保类型安全，避免 ClassCastException
优先使用接口：声明时使用接口类型（List<T> 而非 ArrayList<T>）
线程安全：多线程环境使用 ConcurrentHashMap 或 CopyOnWriteArrayList

总结

Java 集合框架提供了丰富的数据结构选择，理解它们的特性和适用场景，可以帮助写出更高效、更优雅的代码。

目录