本网站已备案:蜀ICP备2026035467号-3

java集合常用方法

一、java集合框架全景概览

Java集合框架(Java Collections Framework)是Java标准库中设计最精妙、使用最频繁的模块之一,它为开发者提供了统一的接口规范与高效的数据结构实现。整个框架以Collection与Map为两大根接口,向下派生出List、Set、Queue等子接口,每种接口均有多个针对性实现类,如ArrayList、LinkedList、HashSet、TreeSet、HashMap、TreeMap等。

自JDK1.2起正式确立集合框架体系,后续版本持续增强:JDK5引入泛型,JDK8加入Stream API与default方法,JDK9增强不可变集合创建方式(如List.of()),JDK16引入Record配合集合使用,JDK19支持Pattern Matching for instanceof简化元素提取,JDK21则新增Virtual Threads与Structured Concurrency,显著提升并发集合操作效率。

核心设计原则包括:①接口与实现分离;②支持泛型类型安全;③提供统一遍历方式(Iterator、forEachRemaining);④支持并发修改检测(fail-fast机制);⑤提供不可变集合视图(Collections.unmodifiableXxx);⑥支持排序与比较(Comparator、Comparable)。

选择合适集合类是开发关键。例如:ArrayList适用于频繁随机访问、尾部插入场景;LinkedList适用于频繁中间插入/删除操作;HashMap提供O(1)平均查询性能但无序;LinkedHashMap保持插入顺序;TreeMap按键排序但查询为O(log n);HashSet去重高效但无序;TreeSet有序但开销较大。

二、List接口核心方法详解

2.1 ArrayList常用方法

ArrayList基于动态数组实现,初始容量为10,扩容时增长为原容量的1.5倍(JDK8起)。其核心方法包括:

  • add(E e):尾部添加元素,均摊时间复杂度O(1),最坏O(n)(需扩容)
  • add(int index, E element):指定位置插入,需移动后续元素,时间复杂度O(n-index)
  • get(int index):随机访问,O(1)
  • set(int index, E element):修改指定位置元素,O(1)
  • remove(int index):删除指定位置元素,需移动后续元素,O(n-index)
  • remove(Object o):删除首次出现的指定元素,需遍历查找,O(n)
  • indexOf(Object o):返回首次出现位置,O(n)
  • lastIndexOf(Object o):返回最后一次出现位置,O(n)
  • contains(Object o):判断是否包含某元素,依赖equals,O(n)
  • size()、isEmpty():O(1)
  • toArray()、toArray(T[] a):集合转数组
  • subList(int fromIndex, int toIndex):返回视图子列表,注意:对子列表修改会影响原列表

陷阱提示:使用removeIf(Predicate)时,若在循环中直接调用remove()可能导致ConcurrentModificationException,应使用迭代器或removeIf(JDK8+)。

2.2 LinkedList常用方法

LinkedList基于双向链表实现,同时实现了Deque接口,可作为列表、栈或队列使用。其核心方法:

  • addFirst(E e)、addLast(E e):头部/尾部添加,O(1)
  • getFirst()、getLast():获取首尾元素,O(1)
  • removeFirst()、removeLast():删除首尾,O(1)
  • push(E e)、pop():栈操作(等同于addFirst与removeFirst)
  • offer(E e)、poll()、peek():队列操作(offer尾部入队,poll头部出队,peek查看头部)
  • listIterator(int index):双向迭代器,支持前后遍历
  • descendingIterator():逆序迭代器(JDK6+)

性能对比:在中间插入/删除场景,LinkedList显著优于ArrayList(无需移动),但在随机访问、遍历场景下ArrayList更快(CPU缓存局部性优势)。实测:10万次随机访问,ArrayList约0.5ms,LinkedList约45ms;10万次中间插入,ArrayList约32ms,LinkedList约1ms。

2.3 Vector与Stack(历史类)

Vector是JDK1.0的线程安全动态数组,方法同步但性能差,已被ArrayList替代。其扩容为2倍,支持capacityIncrement参数。

Stack继承自Vector,提供push、pop、peek、search等栈操作,但设计不合理(继承而非组合),JDK1.2后推荐使用Deque(如ArrayDeque)替代。

三、Set接口核心方法详解

3.1 HashSet

HashSet基于HashMap实现,内部存储为HashMap<E,Object>,值统一为PRESENT常量。关键点:

  • add(E e):通过计算元素hashCode确定桶位置,若冲突则比较equals,时间复杂度O(1)平均
  • contains(Object o):同上,O(1)
  • remove(Object o):O(1)
  • 要求元素重写equals与hashCode,否则无法正确去重
  • 不保证迭代顺序(JDK8起对插入顺序无保证)

自定义类去重示例:

class User {
    String name;
    int id;
    public User(String name, int id) { this.name = name; this.id = id; }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return id == user.id && Objects.equals(name, user.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, id);
    }
}
Set<User> users = new HashSet<>();
users.add(new User("Alice", 1));
users.add(new User("Bob", 2));
System.out.println(users.size()); // 输出:2

3.2 LinkedHashSet

继承自HashSet,内部使用LinkedHashMap存储,通过双向链表维护插入顺序。方法与HashSet一致,但迭代顺序固定为插入顺序,适用于需去重且保留顺序的场景。

3.3 TreeSet

基于TreeMap的红黑树实现,元素自动排序。关键方法:

  • add(E e)、contains、remove:时间复杂度O(log n)
  • first()、last():首尾元素
  • higher(E e):大于e的最小元素
  • lower(E e):小于e的最大元素
  • ceiling(E e):大于等于e的最小元素
  • floor(E e):小于等于e的最大元素
  • subSet(E fromElement, E toElement):子集视图

要求元素实现Comparable,或构造时传入Comparator。支持自然排序与定制排序。

3.4 不可变集合(JDK9+)

JDK9新增工厂方法创建不可变集合:

  • List.of(e1, e2...)、Set.of(e1, e2...)、Map.of(k1, v1, k2, v2...)
  • Set.copyOf(Collection<? extends E> coll):创建副本

特点:不可变、空安全(禁止null)、序列化友好、内存占用更小。尝试修改抛出UnsupportedOperationException。

四、Map接口核心方法详解

4.1 HashMap

核心结构:Node[] table(JDK8+),Node为链表节点;当链表长度≥8且数组长度≥64时转为红黑树。

常用方法:

  • put(K key, V value):插入键值对,key为null时存于索引0处(单个null key)
  • get(Object key):O(1)平均时间
  • containsKey(Object key)、containsValue(Object value):后者需遍历,O(n)
  • remove(Object key):O(1)
  • size()、isEmpty()
  • keySet()、values()、entrySet():返回视图集合
  • putIfAbsent(K key, V value):JDK8+,仅当key不存在时插入
  • computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction):JDK8+,key不存在时计算并插入
  • computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction):key存在时计算更新
  • merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction):合并逻辑

性能调优参数:

  • initialCapacity:初始容量,建议设为2的幂
  • loadFactor:负载因子,默认0.75,平衡空间与时间
  • 避免频繁扩容:提前预估大小,如new HashMap<>(expectedSize / 0.75f + 1)

4.2 LinkedHashMap

在HashMap基础上维护双向链表,支持三种顺序:

  • access-order:构造时传入true,最近访问元素排末尾(用于LRU缓存)
  • insertion-order:默认构造,按插入顺序

重写removeEldestEntry(Map.Entry)可实现自动移除旧元素:

Map<String, String> cache = new LinkedHashMap<>(16, 0.75f, true) {
    @Override
    protected boolean removeEldestEntry(Map.Entry<String, String> eldest) {
        return size() > 100; // 仅保留最近100个
    }
};

4.3 TreeMap

红黑树实现,按键排序。支持:

  • firstKey()、lastKey()
  • subMap(K fromKey, K toKey)、headMap(K toKey)、tailMap(K fromKey)
  • ceilingKey(K key)、floorKey(K key)

适用于需范围查询或排序输出的场景。

4.4 ConcurrentHashMap

JDK8起采用CAS + synchronized实现无锁化(仅在冲突时加锁),分段锁升级为节点锁。核心方法:

  • put(K key, V value):线程安全插入
  • get(Object key):无锁读取
  • computeIfAbsent系列:原子操作
  • mappingCount():返回long类型元素数(JDK8前为size())

注意:containsKey、containsValue等方法在并发场景下结果可能过期,应谨慎使用。

五、集合工具类与Stream API

5.1 Collections工具类

提供静态方法操作集合:

  • synchronizedList(List<T> list):返回线程安全列表(推荐使用CopyOnWriteArrayList)
  • unmodifiableList(List<? extends T> list):不可变视图
  • reverse(List<?> list):反转
  • shuffle(List<?> list):随机打乱
  • sort(List<T> list)、sort(List<T> list, Comparator<? super T> c)
  • binarySearch(List<? extends Comparable> list, T key):二分查找(需已排序)
  • frequency(Collection<?> c, Object o):统计出现次数
  • disjoint(Collection<?> c1, Collection<?> c2):判断是否无交集

5.2 Stream API集合操作

JDK8引入的函数式操作,支持链式处理:

  • stream():创建流
  • filter(Predicate):过滤
  • map(Function):映射
  • sorted()、sorted(Comparator):排序
  • distinct():去重
  • limit(n)、skip(n):截取
  • collect(Collectors.toList()):收集为集合
  • collect(Collectors.groupingBy(Function)):分组
  • collect(Collectors.toMap(Function, Function)):转Map
  • anyMatch、allMatch、noneMatch:条件判断
  • findFirst、findAny:查找
  • reduce:归约

实际案例:统计列表中各字符串长度分布:

List<String> words = Arrays.asList("apple", "banana", "cherry", "apple");
Map<Integer, Long> lengthCount = words.stream()
    .collect(Collectors.groupingBy(String::length, Collectors.counting()));
// 输出:{5=2, 6=1, 7=1}

六、并发集合详解

6.1 CopyOnWriteArrayList

写时复制:每次修改复制新数组,适用于读多写少场景(如监听器列表)。关键方法:

  • add(E e):加锁复制新数组
  • get(int index):无锁读取
  • iterator():迭代器基于快照,不支持remove

适用场景:事件通知、配置管理、只读遍历+少量更新。

6.2 ConcurrentSkipListMap / ConcurrentSkipListSet

基于跳表实现的并发有序Map/Set,支持高并发读写,性能优于ConcurrentHashMap在排序场景。时间复杂度O(log n)。

6.3 BlockingQueue实现

线程安全队列,支持阻塞操作:

  • ArrayBlockingQueue:有界数组队列
  • LinkedBlockingQueue:可选有界链表队列
  • PriorityBlockingQueue:优先级队列
  • SynchronousQueue:无缓冲队列,生产者必须等待消费者

方法:put(E e)(阻塞插入)、take()(阻塞取出)、offer(E e, long timeout, TimeUnit unit)。

七、常见陷阱与最佳实践

7.1 遍历时修改集合

错误示例:

for (String s : list) {
    if (s.equals("a")) list.remove(s); // 抛出ConcurrentModificationException
}

正确方式1(迭代器):

Iterator<String> it = list.iterator();
while (it.hasNext()) {
    if (it.next().equals("a")) it.remove();
}

正确方式2(removeIf):

list.removeIf(s -> s.equals("a"));

7.2 HashMap键的hashCode与equals

若自定义类未正确重写equals与hashCode,可能导致重复键或无法查找:

Map<User, String> map = new HashMap<>();
User u1 = new User("Alice", 1);
User u2 = new User("Alice", 1);
map.put(u1, "dev");
System.out.println(map.get(u2)); // 输出null(因hashCode不同)

必须确保:equals相等 → hashCode相等。

7.3 空值处理

HashMap允许null键(仅一个)与null值;TreeMap不允许null键(抛出NullPointerException);ConcurrentHashMap禁止null键值。

建议统一使用Optional或默认值避免null歧义:

String value = map.getOrDefault("key", "default");