在Java语言体系中,集合(Collection)是用于存储、组织和操作一组对象的核心API框架。它并非单一类,而是一套由接口与其实现类构成的完整体系结构,位于java.util包中,是Java标准库中最基础、最常用的数据结构实现。
从设计角度看,集合是对数组(Array)的有力补充:数组长度固定、类型单一、缺乏高级操作方法,而集合支持动态扩容、自动管理内存、提供丰富遍历与查找方法,并支持泛型类型安全。例如,当需要动态添加学生名单时,用数组需手动扩容并复制数据;用ArrayList只需调用add()方法即可。
Java集合框架整体分为三大体系:Collection(单值集合)、Map(键值对集合)以及辅助工具类(如Collections、Arrays)。其中Collection接口下又派生出List、Set两大子接口,形成清晰的层次结构:
Collection:根接口,定义通用方法如add()、size()、iterator()List:有序可重复集合,支持索引访问(如ArrayList、LinkedList)Set:无序不重复集合,自动去重(如HashSet、TreeSet)Map:键值对映射,键唯一(如HashMap、TreeMap)值得注意的是,java中什么是集合常被误解为仅指Collection接口,实际应理解为整个集合体系。例如,HashMap虽不实现Collection,但属于集合框架的重要成员。这种命名差异源于历史设计:早期JDK将Map独立设计,未纳入Collection体系,但后续版本统一纳入集合框架范畴。
Java集合框架采用接口-实现分离设计,各层级关系如下:
Collection
├── List
│ ├── ArrayList
│ ├── LinkedList
│ └── Vector (线程安全)
└── Set
├── HashSet
├── LinkedHashSet
└── TreeSet
Map
├── HashMap
├── LinkedHashMap
└── TreeMap
所有实现类均遵循统一规范:支持泛型、提供fail-fast迭代器、支持序列化。例如ArrayList与HashSet均继承自AbstractList或AbstractSet抽象类,避免重复代码。
① 高内聚低耦合:接口仅定义行为规范,实现类专注性能优化。
② 动态扩容机制:如ArrayList初始容量10,满载后扩容至1.5倍,避免频繁扩容。
③ 泛型类型安全:JDK5引入后,集合声明如List可防止运行时类型错误。
④ 操作方法统一:所有集合类共享contains()、remove()、size()等基础方法。
Vector、Hashtable等历史遗留类),高并发场景需使用ConcurrentHashMap或Collections.synchronizedList()包装。
List接口继承自Collection,核心特征为:有序(元素插入顺序可预测)、可重复(允许相同元素)、支持索引(通过get(index)快速定位)。适用于需要精确控制元素位置的场景,如任务队列、历史记录。
常用方法示例:
Listlist = new ArrayList<>(); list.add("Java"); // 添加元素 list.add(0, "Hello"); // 指定位置插入 String first = list.get(0); // 索引访问 list.set(1, "World"); // 替换元素 list.remove(0); // 删除指定位置元素
// 内部使用Object[]数组存储
transient Object[] elementData;
// 添加元素时自动扩容
public boolean add(E e) {
ensureCapacityInternal(size + 1);
elementData[size++] = e;
return true;
}
// 扩容逻辑:新容量 = 旧容量 + 旧容量/2
private void grow(int minCapacity) {
int newCapacity = oldCapacity + (oldCapacity >> 1);
elementData = Arrays.copyOf(elementData, newCapacity);
}
ArrayList是List最常用实现类,底层为动态数组,java中什么是集合中其优势在于:
get(i)时间复杂度为O(1)但插入/删除需移动元素,时间复杂度O(n),适用于读多写少场景。例如用户历史订单列表,查询频繁但增删较少。
private static class Node{ E item; Node next; Node prev; Node(Node prev, E element, Node next) { this.item = element; this.next = next; this.prev = prev; } }
LinkedList基于双向链表实现,java中什么是集合中其核心优势:
典型场景:需要频繁在列表中间插入元素(如音乐播放列表拖拽排序)、实现栈/队列结构(addFirst()、pollLast())。
性能对比(10万次操作):
| 操作 | ArrayList | LinkedList |
|---|---|---|
| 尾部添加 | 0.005s | 0.008s |
| 中间插入 | 0.21s | 0.002s |
| 随机访问 | 0.001s | 2.8s |
Vector是JDK1.0的线程安全实现,通过ArrayList替代,仅在遗留系统中可见。例如:
Vectorv = new Vector<>(); v.add(100); // 自动同步,但性能损失约30%
若需线程安全,推荐使用Collections.synchronizedList(new ArrayList<>())或CopyOnWriteArrayList(读多写少场景)。
Set接口继承自Collection,核心特征:无序(不保证插入顺序)、不重复(基于equals()与hashCode()判断)。常用于去重、成员关系判定。例如从日志中提取唯一IP地址:
Listlogs = Arrays.asList("192.168.1.1", "10.0.0.1", "192.168.1.1"); Set uniqueIps = new HashSet<>(logs); // 结果:[192.168.1.1, 10.0.0.1](顺序不固定)
// 内部使用HashMap的key存储元素 private transient HashMapmap; public HashSet() { map = new HashMap<>(); } public boolean add(E e) { return map.put(e, PRESENT)==null; }
HashSet基于HashMap实现,元素存储在HashMap的键中。要求元素类必须正确重写equals()和hashCode(),否则去重失效。例如自定义User类:
public class User {
private String name;
private int age;
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
return age == user.age && Objects.equals(name, user.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age); // 使用Objects工具类
}
}
Setset = new TreeSet<>(); set.add("Java"); set.add("Python"); set.add("C++"); System.out.println(set); // 输出:[C++, Java, Python](自然排序)
TreeSet基于TreeMap实现,元素按自然顺序或自定义比较器排序。支持范围查询(headSet()、tailSet())、获取首尾元素(first()、last())。但插入/删除性能低于HashSet(O(log n) vs O(1))。
典型场景:需要有序集合的场景,如排行榜、优先级队列。
LinkedHashSet结合HashSet的高性能与LinkedList的有序性,内部维护插入顺序的双向链表。适用于需去重且保留插入顺序的场景,如用户操作日志记录:
Setset = new LinkedHashSet<>(); set.add("A"); set.add("B"); set.add("C"); set.add("A"); // 重复元素被忽略 System.out.println(set); // 输出:[A, B, C]
Map存储键值对(Key-Value),键唯一,值可重复。核心操作:put(key, value)、get(key)、containsKey(key)。适用于需要通过键快速查找值的场景,如用户ID到用户对象的映射。
Mapscores = new HashMap<>(); scores.put("Alice", 95); scores.put("Bob", 88); System.out.println(scores.get("Alice")); // 输出:95 System.out.println(scores.containsKey("Bob")); // 输出:true
// 链表转红黑树阈值 static final int TREEIFY_THRESHOLD = 8; // 红黑树转链表阈值 static final int UNTREEIFY_THRESHOLD = 6; // 存储结构 transient Node[] table; // 数组+链表/红黑树 static class Node implements Map.Entry { final int hash; final K key; V value; Node next; }
HashMap是Map最常用实现,JDK1.8后引入红黑树优化:当链表长度≥8且数组容量≥64时转为红黑树,避免哈希冲突导致性能退化为O(n)。
关键参数:
性能优化建议:
Mapmap = new TreeMap<>(); map.put("Java", 100); map.put("Python", 90); map.put("C++", 95); System.out.println(map); // 输出:{C++=95, Java=100, Python=90}
TreeMap基于红黑树实现,键按自然顺序或比较器排序,支持范围操作(subMap()、headMap())。适用于需要排序键值对的场景,如字典、计数器。
LinkedHashMap继承HashMap并维护双向链表,支持两种顺序:
public class LRUCacheextends LinkedHashMap { private final int capacity; public LRUCache(int capacity) { super(capacity, 0.75f, true); // true表示访问顺序 this.capacity = capacity; } @Override protected boolean removeEldestEntry(Map.Entry eldest) { return size() > capacity; // 超容移除最老元素 } }
提供集合操作的静态方法:
// 排序 Listlist = Arrays.asList(3,1,2); Collections.sort(list); // [1,2,3] // 二分查找 int index = Collections.binarySearch(list, 2); // 返回1 // 同步包装 List syncList = Collections.synchronizedList(new ArrayList<>()); // 不可变集合 Set unmodifiable = Collections.unmodifiableSet(new HashSet<>()); // 空集合常量 List> empty = Collections.emptyList(); // 避免null
专为数组设计,但可与集合互转:
// 数组转List
String[] arr = {"A","B","C"};
List list = Arrays.asList(arr);
// List转数组
String[] arr2 = list.toArray(new String[0]);
// 排序与二分查找
Arrays.sort(arr);
int pos = Arrays.binarySearch(arr, "B");
Objects.requireNonNull()避免空指针Stream API(JDK8+)提供函数式操作,如list.stream().filter(...).collect(...)Map.merge()简化计数逻辑:map.merge(key, 1, Integer::sum)
决策树:
LinkedHashMap/LinkedHashSet;否:用HashMap/HashSetTreeMap/TreeSetLinkedList;否:用ArrayListConcurrentHashMap或Collections.synchronizedListremove()而非集合的remove()new Integer(1).equals(1)返回true,但new Integer(1).equals(new Integer(1))需正确重写hashCode()和equals()① 预设容量:创建时指定初始容量,避免动态扩容
// 估算1000个元素 Mapmap = new HashMap<>(1000);
② 使用Immutable对象:作为键时减少hashCode计算开销
③ 避免装箱/拆箱:使用IntStream代替Stream
④ 选择合适初始容量:HashMap默认16,负载因子0.75,当元素数>12时扩容
new ArrayList<>()都会分配内存,应复用实例或使用clear()。
| 特性 | ArrayList | LinkedList | HashSet | HashMap |
|---|---|---|---|---|
| 底层结构 | 动态数组 | 双向链表 | 哈希表 | 哈希表 |
| 有序性 | 有序 | 有序 | 无序 | 无序 |
| 重复性 | 允许 | 允许 | 不允许 | 键唯一 |
| 索引访问 | O(1) | O(n) | 不支持 | 不支持 |
| 插入/删除 | O(n) | O(1) | O(1) | O(1) |
| 查找 | O(n) | O(n) | O(1) | O(1) |
| 内存开销 | 低 | 高 | 中 | 中 |
所有集合操作的时间复杂度基于标准实现:
| 操作 | ArrayList | LinkedList | HashSet | TreeSet | HashMap | TreeMap |
|---|---|---|---|---|---|---|
| 添加 | 均摊O(1) | O(1) | 均摊O(1) | O(log n) | 均摊O(1) | O(log n) |
| 查找 | O(1) | O(n) | O(1) | O(log n) | O(1) | O(log n) |
| 删除 | O(n) | O(1) | O(1) | O(log n) | O(1) | O(log n) |
A:① 线程安全:Vector线程安全(方法加synchronized),ArrayList非线程安全
② 扩容机制:Vector扩容2倍,ArrayList扩容1.5倍
③ 性能:Vector性能较低,已基本淘汰
A:① 线程安全:HashTable线程安全,HashMap非线程安全
② null值:HashMap允许key为null(仅一个),HashTable不允许
③ 迭代器:HashMap迭代器fail-fast,HashTable使用枚举
A:通过元素的hashCode()和equals()实现:
① 先比较hashCode,不同直接存入
② hashCode相同时,比较equals,相同则覆盖,不同存入链表
A:
• 读多写少 → ArrayList
• 插入/删除频繁 → LinkedList
• 需线程安全 → Vector或同步包装
A:① 大小:数组固定,集合动态
② 类型:数组可存基本类型,集合只能存对象
③ 功能:集合提供丰富操作(排序、查找、去重)
④ 泛型:集合支持泛型类型安全,数组协变(有风险)