Java集合类框架的基本接口有哪些？

引言

在Java技术面试中，集合框架相关的问题出现频率高达90%以上。作为Java开发者，深入理解集合框架不仅是面试通关的必备技能，更是编写高效、健壮代码的基石。本文将带你全面剖析Java集合框架的核心接口，并提供实用的面试应对策略。

一、Java集合框架全景概览

1.1 框架设计哲学

Java集合框架（Java Collections Framework，JCF）采用接口与实现分离的设计理念，这一设计充分体现了面向对象编程的"面向接口编程"原则。整个框架建立在几个核心抽象之上，允许开发者根据具体需求选择合适的实现，而不必关心底层数据结构的具体细节。

1.2 历史演进与版本特性

JDK 1.2：首次引入集合框架，包含基本的数据结构
JDK 1.5：加入泛型支持，增强类型安全性
JDK 1.8：引入Stream API和Lambda表达式，函数式编程支持
后续版本：持续优化性能，增加新特性如Records模式匹配等

二、Collection接口体系深度解析

2.1 Collection根接口

作为所有单列集合的顶层接口，Collection定义了集合操作的基本契约：

java 复制代码

public interface Collection<E> extends Iterable<E> {
    // 基本操作
    int size();
    boolean isEmpty();
    boolean contains(Object o);
    boolean add(E e);
    boolean remove(Object o);
    
    // 批量操作
    boolean containsAll(Collection<?> c);
    boolean addAll(Collection<? extends E> c);
    boolean removeAll(Collection<?> c);
    
    // 数组转换
    Object[] toArray();
    <T> T[] toArray(T[] a);
    
    // JDK 8+ 默认方法
    default boolean removeIf(Predicate<? super E> filter) {
        // 实现省略
    }
}

2.2 List接口：有序集合的王国

特点：元素有序、可重复、支持索引访问

java 复制代码

public interface List<E> extends Collection<E> {
    // 位置访问操作
    E get(int index);
    E set(int index, E element);
    void add(int index, E element);
    E remove(int index);
    
    // 搜索操作
    int indexOf(Object o);
    int lastIndexOf(Object o);
    
    // 列表迭代器
    ListIterator<E> listIterator();
    ListIterator<E> listIterator(int index);
    
    // 子列表视图
    List<E> subList(int fromIndex, int toIndex);
}

核心实现类对比：

特性	ArrayList	LinkedList	Vector
数据结构	动态数组	双向链表	动态数组
线程安全	否	否	是
随机访问	O(1)	O(n)	O(1)
插入删除	O(n)	O(1)	O(n)
扩容机制	1.5倍	无需扩容	2倍

2.3 Set接口：唯一性保证者

特点：元素唯一、无序（LinkedHashSet除外）、不重复

java 复制代码

public interface Set<E> extends Collection<E> {
    // 继承Collection的所有方法
    // 添加了关于数学集合操作的约定
}

重要实现类解析：

HashSet：基于HashMap实现，依赖hashCode()和equals()

java 复制代码

Set<String> hashSet = new HashSet<>();
// 添加元素时，先计算hashCode，再判断equals

LinkedHashSet：继承HashSet，维护插入顺序

java 复制代码

Set<String> linkedSet = new LinkedHashSet<>();
// 内部使用链表维护顺序

TreeSet：基于TreeMap实现，元素有序

java 复制代码

Set<String> treeSet = new TreeSet<>();
// 元素必须实现Comparable或提供Comparator

2.4 Queue接口：先进先出的队列

特点：FIFO（先进先出）操作，支持优先级队列

java 复制代码

public interface Queue<E> extends Collection<E> {
    // 插入操作
    boolean offer(E e);    // 推荐使用，失败返回false
    boolean add(E e);      // 可能抛出异常
    
    // 移除操作
    E poll();              // 返回并移除队首
    E remove();            // 可能抛出异常
    
    // 检查操作
    E peek();              // 查看队首但不移除
    E element();           // 可能抛出异常
}

Deque接口：双端队列，支持两端操作

java 复制代码

Deque<String> deque = new ArrayDeque<>();
deque.offerFirst("First");
deque.offerLast("Last");

三、Map接口体系全面剖析

3.1 Map根接口：键值对的存储中心

Map与Collection并列，是集合框架的另一大支柱：

java 复制代码

public interface Map<K, V> {
    // 基本操作
    V put(K key, V value);
    V get(Object key);
    V remove(Object key);
    boolean containsKey(Object key);
    
    // 视图操作
    Set<K> keySet();
    Collection<V> values();
    Set<Map.Entry<K, V>> entrySet();
    
    // 内部接口Entry
    interface Entry<K, V> {
        K getKey();
        V getValue();
        V setValue(V value);
    }
}

3.2 主要Map实现对比分析

HashMap深度解析：

java 复制代码

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
    
    // 核心字段
    transient Node<K,V>[] table;      // 哈希表数组
    int threshold;                     // 扩容阈值
    final float loadFactor;            // 负载因子（默认0.75）
    
    // 节点结构：链表或红黑树
    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;
    }
}

扩容机制：

初始容量：16
负载因子：0.75
扩容时机：size > capacity * loadFactor
扩容操作：容量翻倍，重新哈希

并发修改问题：

java 复制代码

Map<String, Integer> map = new HashMap<>();
// 错误的遍历修改方式
for (String key : map.keySet()) {
    if (key.equals("remove")) {
        map.remove(key); // 抛出ConcurrentModificationException
    }
}
// 正确的遍历修改方式
map.keySet().removeIf(key -> key.equals("remove"));

3.3 特殊Map实现类

LinkedHashMap：保持插入顺序或访问顺序

java 复制代码

Map<String, Integer> lruCache = new LinkedHashMap<>(
    16, 0.75f, true  // accessOrder设置为true实现LRU
);

TreeMap：基于红黑树的NavigableMap实现

java 复制代码

TreeMap<String, Integer> treeMap = new TreeMap<>();
// 支持范围查询、排序视图等操作

ConcurrentHashMap：线程安全的HashMap

java 复制代码

ConcurrentHashMap<String, Integer> concurrentMap = 
    new ConcurrentHashMap<>();
// JDK 1.8采用CAS+synchronized实现分段锁

四、迭代器与工具类

4.1 Iterator模式

java 复制代码

public interface Iterator<E> {
    boolean hasNext();
    E next();
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }
    
    // JDK 8+ 新增
    default void forEachRemaining(Consumer<? super E> action) {
        while (hasNext())
            action.accept(next());
    }
}

4.2 Collections工具类实战

java 复制代码

// 创建不可变集合
List<String> immutableList = Collections.unmodifiableList(list);
Set<String> singletonSet = Collections.singleton("唯一元素");

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

// 算法操作
Collections.sort(list, Comparator.reverseOrder());
Collections.binarySearch(list, "target");
Collections.rotate(list, 2); // 旋转操作

五、面试要点深度总结

5.1 必须掌握的面试问题

ArrayList vs LinkedList
- 底层数据结构差异
- 时间复杂度对比
- 内存占用分析
HashMap工作原理
- 哈希碰撞解决方案
- 扩容机制详解
- 线程安全性分析
ConcurrentHashMap演进
- JDK 1.7：Segment分段锁
- JDK 1.8：CAS + synchronized

5.2 高级话题准备

Fail-Fast与Fail-Safe机制

java 复制代码

// Fail-Fast：快速失败，检测到并发修改抛出异常
// Fail-Safe：安全失败，遍历副本不影响原集合

时间复杂度分析

操作 ArrayList LinkedList HashMap

添加 O(1)* O(1) O(1)*

删除 O(n) O(1) O(1)*

查找 O(1) O(n) O(1)*
内存布局优化
- 对象头开销
- 指针压缩
- 数组与链表的空间效率

操作	ArrayList	LinkedList	HashMap
添加	O(1)*	O(1)	O(1)*
删除	O(n)	O(1)	O(1)*
查找	O(1)	O(n)	O(1)*

5.3 实战编码技巧

java 复制代码

// 1. 选择合适的初始容量
List<String> list = new ArrayList<>(100); // 避免频繁扩容

// 2. 使用EntrySet遍历Map
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    // 比先获取key再获取value更高效
}

// 3. 线程安全集合的使用
Map<String, Integer> concurrentMap = new ConcurrentHashMap<>();
// 使用compute、merge等原子操作方法
concurrentMap.computeIfAbsent("key", k -> 0);