Java 四大核心集合（List/Set/Queue/Map）详解

最新推荐文章于 2025-12-19 15:39:34 发布
原创 最新推荐文章于 2025-12-19 15:39:34 发布 · 659 阅读 · 8 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #list #开发语言 #数据结构 #开源软件

Java 四大核心集合（List/Set/Queue/Map）详解

一、Java 集合框架总览

Java 集合框架（Java Collections Framework, JCF）是用于存储、操作数据的核心 API，位于 java.util 包下，核心目标是 提供统一、高效的数据结构操作接口，替代数组的局限性（固定长度、操作繁琐）。

1.1 核心体系结构

Java 集合框架分为两大核心分支：

  • Collection 接口：存储「单个元素」的集合，子接口包括 List（有序可重复）、Set（无序不可重复）、Queue（先进先出）；
  • Map 接口：存储「键值对（Key-Value）」的集合，不继承 Collection，是独立的顶层接口。

1.2 核心接口关系表

顶层接口核心子接口 / 实现类存储类型核心特征
CollectionList（ArrayList、LinkedList）单个元素有序、可重复、有索引
CollectionSet（HashSet、LinkedHashSet、TreeSet）单个元素无序、不可重复
CollectionQueue（ArrayDeque、PriorityQueue、BlockingQueue）单个元素先进先出（FIFO）/ 优先级排序
MapHashMap、LinkedHashMap、TreeMap、ConcurrentHashMap键值对Key 唯一、Value 可重复

1.3 集合与数组的区别

特性集合（如 List/Map）数组
长度动态扩容（无需指定初始长度）固定长度（初始化后不可变）
存储类型只能存储引用类型（基本类型需装箱为包装类）可存储基本类型 / 引用类型
操作 API提供丰富方法（add/remove/get/contains 等）仅支持索引访问，无内置操作方法
灵活性高（支持排序、遍历、查找、扩容）低（需手动实现排序、扩容等逻辑）

二、List 详解：有序可重复的「动态数组」

2.1 核心特性

  • 有序性：元素存储顺序与插入顺序一致，支持通过「索引」访问（0 起始）；
  • 可重复性：允许存储多个相等元素（equals() 返回 true）；
  • 索引操作：支持通过索引增删改查（如 get(int index)、remove(int index)）；
  • 非线程安全：默认实现（ArrayList、LinkedList）均为线程不安全，并发场景需手动同步。

2.2 常用实现类对比

实现类底层结构有序性重复性线程安全查询效率增删效率（中间 / 末尾）初始容量扩容机制
ArrayList动态数组（Object []）插入有序允许否高（O (1)，索引直接访问）中间：低（O (n)，需数组拷贝）；末尾：高（O (1)）10（JDK8）扩容为原容量的 1.5 倍（oldCapacity + (oldCapacity >> 1)）
LinkedList双向链表插入有序允许否低（O (n)，需遍历链表）中间 / 末尾：高（O (1)，仅需修改指针）无（链表无容量概念）无需扩容（链表节点动态新增）
Vector动态数组（Object []）插入有序允许是（方法加 synchronized）高（O (1)）中间：低（O (n)）；末尾：高（O (1)）10扩容为原容量的 2 倍
CopyOnWriteArrayListCopyOnWrite 数组（写时复制）插入有序允许是（读写分离）高（O (1)）低（O (n)，写操作需复制整个数组）0（初始为空数组）扩容为原容量 + 1（每次写操作新建数组）

2.3 底层原理与关键机制

（1）ArrayList 核心机制

  • 动态扩容

    ：当元素数量超过容量（size >= capacity）时，触发扩容：

    1. 计算新容量：newCapacity = oldCapacity + (oldCapacity >> 1)（1.5 倍）；
    2. 若新容量仍不足（如手动添加大量元素），直接扩容为需求容量；
    3. 通过 Arrays.copyOf() 复制原数组到新数组，开销较大。

  • 缩容：默认不支持自动缩容（即使删除大量元素，容量仍不变），需手动调用 trimToSize() 释放空闲内存。

（2）LinkedList 核心机制
  • 底层是「双向链表」，每个节点（Node）包含 prev（前驱指针）、item（元素）、next（后继指针）；
  • 实现了 Deque 接口，支持双端操作（如 addFirst()、removeLast()），可作为队列 / 栈使用；
  • 无索引，查询需从表头 / 表尾遍历，效率低下。
（3）CopyOnWriteArrayList 核心机制
  • 「写时复制」：读操作直接访问原数组（无锁，高效），写操作（add/remove）时复制原数组生成新数组，修改后替换原数组引用；
  • 优点：读操作无并发冲突，无需加锁；缺点：写操作开销大，存在数据一致性问题（读可能获取旧数据）。

2.4 常用方法示例

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class ListDemo {
    public static void main(String[] args) {
        // 1. ArrayList 示例（查询优先）
        List<String> arrayList = new ArrayList<>();
        arrayList.add("Java"); // 末尾添加：O(1)
        arrayList.add("Python");
        arrayList.add(1, "Golang"); // 中间插入：O(n)，需数组拷贝
        System.out.println("ArrayList 元素：" + arrayList); // [Java, Golang, Python]
        System.out.println("索引 1 元素：" + arrayList.get(1)); // Golang（O(1)）
        arrayList.remove(2); // 移除索引 2 元素：O(n)
        System.out.println("移除后：" + arrayList); // [Java, Golang]

        // 2. LinkedList 示例（增删优先，双端操作）
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.addFirst("Redis"); // 表头添加：O(1)
        linkedList.addLast("MySQL"); // 表尾添加：O(1)
        linkedList.push("MongoDB"); // 栈操作（等价于 addFirst）
        System.out.println("LinkedList 元素：" + linkedList); // [MongoDB, Redis, MySQL]
        System.out.println("表头元素：" + linkedList.getFirst()); // MongoDB（O(1)）
        System.out.println("表尾元素：" + linkedList.getLast()); // MySQL（O(1)）
        linkedList.pop(); // 栈弹出（等价于 removeFirst）
        System.out.println("弹出后：" + linkedList); // [Redis, MySQL]
    }
}

2.5 线程安全问题与解决方案

（1）问题：

默认实现（ArrayList、LinkedList）在多线程并发读写时，可能出现 ConcurrentModificationException（快速失败）、数据错乱等问题。

（2）解决方案：
  1. 手动同步：使用 synchronized 或 ReentrantLock 包裹集合操作；
  2. 使用线程安全实现类：
    • 低并发：Vector（效率低，不推荐）；
    • 高并发读、低并发写：CopyOnWriteArrayList（读无锁，写复制）；
  3. 工具类包装：Collections.synchronizedList(new ArrayList<>())（底层通过同步代码块实现，效率一般）。

2.6 适用场景

  • ArrayList：查询频繁、增删少（如数据展示、配置列表）；
  • LinkedList：增删频繁、查询少（如队列、栈、链表结构数据）；
  • CopyOnWriteArrayList：高并发读场景（如缓存列表、日志收集）；
  • Vector：遗留系统兼容（不推荐新代码使用）。

三、Set 详解：无序不可重复的「集合」

3.1 核心特性

  • 无序性：元素存储顺序与插入顺序无关（LinkedHashSet 除外，维护插入顺序）；
  • 不可重复性：不允许存储相等元素（通过 equals() 和 hashCode() 判断）；
  • 无索引：不支持通过索引访问，仅支持遍历、包含判断；
  • 非线程安全：默认实现（HashSet、TreeSet）均为线程不安全。

3.2 常用实现类对比

实现类底层结构有序性去重机制线程安全查找效率插入效率元素要求
HashSet哈希表（基于 HashMap，元素存于 Key 位）无序hashCode() + equals()否高（O (1)，哈希冲突时 O (n)）高（O (1)）需重写 hashCode() 和 equals()
LinkedHashSet哈希表 + 双向链表（基于 LinkedHashMap）插入有序hashCode() + equals()否高（O (1)）中（比 HashSet 多维护链表）需重写 hashCode() 和 equals()
TreeSet红黑树（基于 TreeMap，元素存于 Key 位）自然排序 / 定制排序Comparable.compareTo() 或 Comparator否中（O (log n)，红黑树查找）中（O (log n)）元素需可比较（实现 Comparable 或传入 Comparator）
CopyOnWriteArraySetCopyOnWrite 数组（基于 CopyOnWriteArrayList）插入有序equals()是（读写分离）低（O (n)，需遍历数组）低（O (n)，写复制）需重写 equals()

3.3 去重原理（核心！）

Set 的不可重复性依赖以下两个方法，必须同时满足：

  1. hashCode()：计算元素的哈希值，决定元素在哈希表中的存储位置（桶位）；
  2. equals()：判断两个元素是否逻辑相等。
去重流程（以 HashSet 为例）：
  1. 新增元素时，先调用元素的 hashCode() 得到哈希值，找到对应的桶位；
  2. 若桶位为空，直接存入元素；
  3. 若桶位不为空，遍历桶内元素，通过 equals()对比：
    • 若存在 equals() 返回 true 的元素，拒绝插入；
    • 若所有元素 equals() 返回 false，存入桶内（哈希冲突，链表 / 红黑树存储）。
关键规范：
  • 若 a.equals(b) = true，则 a.hashCode() 必须等于 b.hashCode()；
  • 若 a.hashCode() = b.hashCode()，a.equals(b) 可不为 true（哈希冲突）；
  • 自定义对象作为 Set 元素时，必须重写 hashCode() 和 equals()，否则无法保证去重。

3.4 常用方法示例

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.TreeSet;

public class SetDemo {
    static class User {
        private String id;
        private String name;

        public User(String id, String name) {
            this.id = id;
            this.name = name;
        }

        // 重写 equals() 和 hashCode()（关键：基于 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.equals(user.id);
        }

        @Override
        public int hashCode() {
            return id.hashCode();
        }

        @Override
        public String toString() {
            return "User{id='" + id + "', name='" + name + "'}";
        }
    }

    public static void main(String[] args) {
        // 1. HashSet（无序去重）
        HashSet<User> hashSet = new HashSet<>();
        hashSet.add(new User("1", "张三"));
        hashSet.add(new User("2", "李四"));
        hashSet.add(new User("1", "张三（重复）")); // 去重（id 相同）
        System.out.println("HashSet 元素（无序）：" + hashSet);
        // 输出：[User{id='1', name='张三'}, User{id='2', name='李四'}]

        // 2. LinkedHashSet（插入有序去重）
        LinkedHashSet<User> linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add(new User("3", "王五"));
        linkedHashSet.add(new User("4", "赵六"));
        linkedHashSet.add(new User("3", "王五（重复）")); // 去重
        System.out.println("LinkedHashSet 元素（插入有序）：" + linkedHashSet);
        // 输出：[User{id='3', name='王五'}, User{id='4', name='赵六'}]

        // 3. TreeSet（自然排序，需实现 Comparable）
        TreeSet<Integer> treeSet = new TreeSet<>();
        treeSet.add(3);
        treeSet.add(1);
        treeSet.add(2);
        treeSet.add(3); // 去重
        System.out.println("TreeSet 元素（自然排序）：" + treeSet); // [1, 2, 3]

        // 定制排序（按 User.name 长度排序）
        TreeSet<User> customTreeSet = new TreeSet<>((u1, u2) -> u1.name.length() - u2.name.length());
        customTreeSet.add(new User("5", "小明"));
        customTreeSet.add(new User("6", "小红"));
        customTreeSet.add(new User("7", "王大明"));
        System.out.println("TreeSet 定制排序：" + customTreeSet);
        // 输出：[User{id='5', name='小明'}, User{id='6', name='小红'}, User{id='7', name='王大明'}]
    }
}

3.5 线程安全问题与解决方案

（1）问题：

默认实现（HashSet、TreeSet）并发读写时，可能出现 ConcurrentModificationException、数据重复插入等问题。

（2）解决方案：
  1. 工具类包装：Collections.synchronizedSet(new HashSet<>())；
  2. 并发安全实现类：
    • 高并发读、低并发写：CopyOnWriteArraySet（基于 CopyOnWriteArrayList，去重依赖 equals()）；
    • 高并发读写：ConcurrentSkipListSet（基于跳表，有序，线程安全，效率高于 CopyOnWriteArraySet）。

3.6 适用场景

  • HashSet：无需有序、需快速去重（如用户 ID 集合、标签集合）；
  • LinkedHashSet：需有序去重（如历史记录、访问轨迹）；
  • TreeSet：需排序的去重集合（如排行榜、有序数据筛选）；
  • CopyOnWriteArraySet：高并发读场景的去重集合（如并发日志去重）。

四、Queue 详解：先进先出的「队列」

4.1 核心特性

  • FIFO 原则：默认先进先出（PriorityQueue 除外，按优先级排序）；
  • 队列操作：支持「插入、移除、查看」三类核心操作，每种操作提供两种实现（失败抛异常 / 返回特殊值）；
  • 双端队列：部分实现（如 LinkedList、ArrayDeque）支持双端操作（头 / 尾均可插入 / 移除），可作为栈使用；
  • 阻塞队列：支持阻塞等待（无元素时移除阻塞，无空间时插入阻塞），适用于并发场景。

4.2 核心方法对比（Queue 接口）

操作类型失败抛异常失败返回特殊值说明
插入元素add(E e)offer(E e)add 超出容量抛 IllegalStateException，offer 返回 false
移除元素remove()poll()remove 无元素抛 NoSuchElementException，poll 返回 null
查看队首元素element()peek()element 无元素抛 NoSuchElementException，peek 返回 null

4.3 常用实现类对比

实现类底层结构队列类型有序性线程安全容量限制核心特点
LinkedList双向链表双端队列（Deque）FIFO否无（动态扩容）支持双端操作，可作为队列 / 栈使用
ArrayDeque循环数组双端队列（Deque）FIFO否无（动态扩容）数组实现，效率高于 LinkedList，支持栈操作（push/pop）
PriorityQueue小顶堆（数组实现）优先级队列自然排序 / 定制排序否无（动态扩容）不遵循 FIFO，按优先级取出元素（默认小顶堆）
ConcurrentLinkedQueue单向链表并发队列FIFO是（CAS 无锁）无高并发场景下高效，非阻塞
ArrayBlockingQueue数组阻塞队列（BlockingQueue）FIFO是（ReentrantLock）有界（需指定容量）数组实现，公平 / 非公平锁可选
LinkedBlockingQueue双向链表阻塞队列（BlockingQueue）FIFO是（ReentrantLock）可选有界（默认无界）链表实现，吞吐量高于 ArrayBlockingQueue
SynchronousQueue无存储结构同步队列FIFO是无界（但每次只能存 1 个元素）插入操作需等待移除操作，适用于线程间数据传递

4.4 底层原理与关键机制

（1）PriorityQueue 核心机制
  • 底层是「小顶堆」（完全二叉树的数组实现），默认按自然排序（元素需实现 Comparable）；
  • 插入元素时，通过「上浮」调整堆结构（确保父节点小于子节点）；
  • 移除队首元素时，通过「下沉」调整堆结构（确保堆顶是最小值）；
  • 注意：PriorityQueue 不是线程安全的，并发场景需使用 PriorityBlockingQueue。
（2）BlockingQueue 核心机制
  • 基于「锁 + 条件变量」实现阻塞：
    • put(E e)：队列满时阻塞，直到有空间；
    • take()：队列空时阻塞，直到有元素；
    • 支持超时阻塞（offer(E e, long timeout, TimeUnit unit)、poll(long timeout, TimeUnit unit)）；
  • 适用于生产者 - 消费者模型（生产者插入元素，消费者移除元素，自动协调并发）。

4.5 常用方法示例

import java.util.PriorityQueue;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;

public class QueueDemo {
    public static void main(String[] args) throws InterruptedException {
        // 1. PriorityQueue（优先级队列，小顶堆）
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
        priorityQueue.offer(3);
        priorityQueue.offer(1);
        priorityQueue.offer(2);
        System.out.println("PriorityQueue 队首：" + priorityQueue.peek()); // 1（最小值）
        while (!priorityQueue.isEmpty()) {
            System.out.print(priorityQueue.poll() + " "); // 1 2 3（按优先级取出）
        }
        System.out.println();

        // 2. ArrayBlockingQueue（有界阻塞队列，生产者-消费者示例）
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(2); // 容量 2

        // 生产者线程
        new Thread(() -> {
            try {
                blockingQueue.put("任务1");
                System.out.println("生产者：放入任务1");
                blockingQueue.put("任务2");
                System.out.println("生产者：放入任务2");
                blockingQueue.put("任务3"); // 队列满，阻塞
                System.out.println("生产者：放入任务3");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "Producer").start();

        // 消费者线程
        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(1); // 休眠 1 秒，模拟处理时间
                System.out.println("消费者：取出" + blockingQueue.take()); // 取出任务1，队列有空间，生产者继续放入任务3
                TimeUnit.SECONDS.sleep(1);
                System.out.println("消费者：取出" + blockingQueue.take()); // 取出任务2
                TimeUnit.SECONDS.sleep(1);
                System.out.println("消费者：取出" + blockingQueue.take()); // 取出任务3
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "Consumer").start();
    }
}

4.6 适用场景

  • LinkedList/ArrayDeque：普通队列 / 栈操作（如任务临时存储、栈结构计算）；
  • PriorityQueue：优先级任务调度（如任务优先级排序、Top K 问题）；
  • ConcurrentLinkedQueue：高并发非阻塞队列（如日志收集、无阻塞任务队列）；
  • ArrayBlockingQueue/LinkedBlockingQueue：生产者 - 消费者模型（如线程池任务队列、消息队列）；
  • SynchronousQueue：线程间同步通信（如线程池的 SynchronousQueue 用于直接提交任务）。

五、Map 详解：键值对映射的「字典」

5.1 核心特性

  • 键值对存储：每个元素是 Entry<K, V> 对象（Key-Value 映射）；
  • Key 唯一性：Key 不可重复（基于 hashCode() 和 equals() 判断），Value 可重复；
  • 无序性：默认实现（HashMap）无序，LinkedHashMap 维护插入顺序，TreeMap 维护排序顺序；
  • 非线程安全：默认实现（HashMap、LinkedHashMap）均为线程不安全。

5.2 常用实现类对比

实现类底层结构有序性Key 唯一性线程安全查找效率插入效率Key/Value 限制
HashMapJDK7：数组 + 链表；JDK8：数组 + 链表 / 红黑树无序hashCode() + equals()否高（O (1)，冲突时 O (log n)）高（O (1)）Key 可 null（仅 1 个），Value 可 null
LinkedHashMap哈希表 + 双向链表插入有序 / 访问有序hashCode() + equals()否高（O (1)）中（比 HashMap 多维护链表）Key 可 null，Value 可 null
TreeMap红黑树自然排序 / 定制排序Comparable.compareTo() 或 Comparator否中（O (log n)）中（O (log n)）Key 不可 null，Value 可 null
Hashtable数组 + 链表无序hashCode() + equals()是（方法加 synchronized）低（O (1)，冲突时 O (n)）低Key/Value 均不可 null
ConcurrentHashMapJDK7：分段锁；JDK8：数组 + 链表 / 红黑树 + CAS+synchronized无序hashCode() + equals()是（并发安全）高（接近 HashMap）高（接近 HashMap）Key/Value 均不可 null

5.3 底层原理与关键机制

（1）HashMap 核心机制（JDK8）
  • 底层结构：数组（桶）+ 链表 + 红黑树（哈希冲突解决）；
    • 数组：存储 Entry 对象，初始容量 16（2^4），必须是 2 的幂（便于哈希计算）；
    • 链表：哈希冲突时，元素链化（链表长度 <= 8 时）；
    • 红黑树：链表长度 >= 8 且数组长度 >= 64 时，链表转为红黑树（提升查询效率）。
  • 哈希计算：index = (n - 1) & hash（n 为数组长度，保证 index 在数组范围内）；
  • 负载因子：默认 0.75（平衡空间与时间），当 size > capacity * loadFactor 时触发扩容；
  • 扩容机制：扩容为原容量的 2 倍，重新计算所有元素的哈希值并迁移（rehash）。
（2）ConcurrentHashMap 核心机制（JDK8）
  • 放弃 JDK7 的「分段锁」，采用「CAS + synchronized」实现并发安全：
    • 对数组桶的头节点加 synchronized 锁，减少锁竞争（粒度更细）；
    • 读操作无锁（volatile 保证可见性）；
    • 支持高并发读写，吞吐量远高于 Hashtable。
（3）LinkedHashMap 核心机制
  • 基于 HashMap，额外维护一条「双向链表」，记录元素的插入顺序或访问顺序；
  • 可通过构造函数指定访问顺序（accessOrder = true），适用于 LRU 缓存（最近最少使用淘汰）。

5.4 常用方法示例

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.TreeMap;
import java.util.concurrent.ConcurrentHashMap;

public class MapDemo {
    public static void main(String[] args) {
        // 1. HashMap（无序，Key 唯一）
        Map<String, Integer> hashMap = new HashMap<>();
        hashMap.put("Java", 95);
        hashMap.put("Python", 85);
        hashMap.put("Java", 100); // Key 重复，覆盖 Value
        System.out.println("HashMap：" + hashMap); // {Java=100, Python=85}（无序）
        System.out.println("获取 Java 分数：" + hashMap.get("Java")); // 100
        System.out.println("是否包含 Key Python：" + hashMap.containsKey("Python")); // true

        // 2. LinkedHashMap（插入有序）
        Map<String, Integer> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put("Java", 95);
        linkedHashMap.put("Python", 85);
        linkedHashMap.put("Golang", 90);
        System.out.println("LinkedHashMap（插入有序）：" + linkedHashMap);
        // 输出：{Java=95, Python=85, Golang=90}

        // 3. TreeMap（自然排序）
        Map<String, Integer> treeMap = new TreeMap<>();
        treeMap.put("C", 80);
        treeMap.put("A", 90);
        treeMap.put("B", 85);
        System.out.println("TreeMap（自然排序）：" + treeMap); // {A=90, B=85, C=80}

        // 4. ConcurrentHashMap（并发安全）
        Map<String, Integer> concurrentHashMap = new ConcurrentHashMap<>();
        // 多线程并发操作（无异常）
        new Thread(() -> concurrentHashMap.put("线程1", 1)).start();
        new Thread(() -> concurrentHashMap.put("线程2", 2)).start();
        new Thread(() -> System.out.println("ConcurrentHashMap：" + concurrentHashMap)).start();
    }
}

5.5 线程安全问题与解决方案

（1）问题：

默认实现（HashMap、LinkedHashMap）并发读写时，可能出现 ConcurrentModificationException、数据错乱、扩容死循环（JDK7）等问题。

（2）解决方案：
  1. 工具类包装：Collections.synchronizedMap(new HashMap<>())（底层同步代码块，效率一般）；
  2. 线程安全实现类：
    • 遗留系统：Hashtable（效率低，不推荐）；
    • 高并发场景：ConcurrentHashMap（JDK8 效率高，推荐）；
    • 有序并发：ConcurrentSkipListMap（基于跳表，有序，并发安全）。

5.6 适用场景

  • HashMap：普通键值对映射（如配置存储、缓存、字典查询）；
  • LinkedHashMap：有序键值对（如历史记录、LRU 缓存）；
  • TreeMap：有序键值对排序（如排行榜、区间查询）；
  • ConcurrentHashMap：高并发键值对映射（如分布式缓存、并发配置存储）；
  • ConcurrentSkipListMap：高并发有序键值对（如并发排行榜）。

六、四大集合核心对比总结

集合类型核心特征有序性重复性线程安全（默认）常用实现类核心用途
List索引访问插入有序允许否ArrayList、LinkedList动态数组、有序列表
Set不可重复无序（LinkedHashSet 除外）禁止否HashSet、TreeSet去重、集合运算
QueueFIFO / 优先级FIFO（PriorityQueue 除外）允许否ArrayDeque、BlockingQueue队列、任务调度
Map键值对无序（LinkedHashSet/TreeMap 除外）Key 禁止、Value 允许否HashMap、ConcurrentHashMap字典映射、缓存

七、常见问题与注意事项

7.1 equals () 与 hashCode () 重写规范

  • 适用场景：Set 元素、Map Key 为自定义对象时；
  • 规范：
    1. 若 a.equals(b) = true，则 a.hashCode() = b.hashCode()；
    2. 若 a.hashCode() != b.hashCode()，则 a.equals(b) = false；
    3. 重写 equals() 必须重写 hashCode()，反之不必然；
  • 示例：基于对象的核心字段（如 ID）重写，避免使用默认的 Object 类实现（基于内存地址）。

7.2 fail-fast 与 fail-safe 机制

  • fail-fast（快速失败）：
    • 触发场景：ArrayList、HashMap 等集合在迭代时，若其他线程修改集合（add/remove），会抛出 ConcurrentModificationException；
    • 原理：迭代器维护 modCount（修改次数），迭代时检查 modCount 是否变化；
    • 注意：单线程迭代时，若通过集合自身方法（而非迭代器）修改集合，也会触发。
  • fail-safe（安全失败）：
    • 触发场景：CopyOnWriteArrayList、ConcurrentHashMap 等并发集合；
    • 原理：迭代时访问集合的「快照」（如 CopyOnWrite 数组的原数组），修改操作不影响迭代；
    • 缺点：可能读取到旧数据，写操作开销大。

7.3 集合选型建议

  1. 需有序、可重复、索引访问 → List：
    • 查询多 → ArrayList；
    • 增删多 → LinkedList；
    • 并发读 → CopyOnWriteArrayList。
  2. 需去重 → Set：
    • 无序 → HashSet；
    • 有序 → LinkedHashSet；
    • 排序 → TreeSet；
    • 并发 → CopyOnWriteArraySet。
  3. 需队列 / 栈操作 → Queue：
    • 普通队列 / 栈 → ArrayDeque；
    • 优先级 → PriorityQueue；
    • 并发阻塞 → ArrayBlockingQueue/LinkedBlockingQueue。
  4. 需键值对映射 → Map：
    • 普通映射 → HashMap；
    • 有序映射 → LinkedHashMap/TreeMap；
    • 并发映射 → ConcurrentHashMap。

八、总结

Java 四大核心集合（List/Set/Queue/Map）是日常开发中最常用的数据结构，其设计遵循「接口统一、实现差异化」的原则：

  • List 侧重「有序可重复」，提供索引访问；
  • Set 侧重「无序不可重复」，提供去重能力；
  • Queue 侧重「队列操作」，支持 FIFO / 优先级 / 阻塞；
  • Map 侧重「键值对映射」，提供高效查找。
java集合（List、Set、Map等类详解）
sjjsaaaa的博客
07-28 531
集合 一、Collection接口 集合（collection）有时又称为容器，简单地说，它是一个对象，能将具有相同性质的多个元素汇聚成一个整体 集合被用于存储、获取、操纵和传输聚合的数据 集合框架（Collections Framework）是用来表现和操纵集合的一个统一的体系结构。所有的集合框架都包含以下内容： 接口：是代表集合的抽象数据类型。 实现：是集合接口的具体实现。本质上，它们是可重用的数据结构，是一些类。 算法：是在实现了集合接口的对象上执行有用的计算的方法，如查找和排序。 二、Iter
手撕Java系列-集合框架详解，List，Set，Queue，Deque，Map，并发集合，集合工具类，Stream API
横竖撇折点
10-26 1279
手撕Java系列-集合框架详解，List，Set，Queue，Deque，Map，并发集合，集合工具类，Stream API
Java集合类详解：List、Set、Queue、Map、Stack的特点与用法
✨ 欢迎来到【Seal ^_^ 的优快云博客】！✨
06-15 6410
在Java中，集合类（Collections Framework）是一个非常重要的部分，它提供了多种数据结构的实现，以便我们在开发中更方便地管理和操作数据。 本文将详细介绍Java中的几种主要集合类：List、Set、Queue、Map和Stack的特点和用法。
Java集合中List,Set以及Map等集合体系详解(史上最全)
热门推荐
君羊
06-12 33万+
概述: List Set Map都是接口，前两个继承至Collection接口，Map为独立接口 Set下有HashSet，LinkedHashSet，TreeSet List下有ArrayList，Vector，LinkedList Map下有Hashtable，LinkedHashMap，HashMap，TreeMap 还有Collection接口下还有个Queue接口，有Priority...
java集合总结-List/Set/Map/Queue
fancor的专栏
07-18 3678
从书上和网上搜索各种资料整理而成，相信是比较全的了。 一、基本概念 1、迭代器 Iterator接口包含3个方法： public interface Iterator{   E next();   boolean hasNext();   void remove(); } 通过反复调用next方法可以访问集合中每个元素，但需要在调用next之前调用hasNext方
Java基础之集合详解（List、Queue、Set、Map）
qq_41389482的博客
01-03 883
文章目录集合List：可重复ArrayListVectorLinkedListQueueSet：不可重复HashSet：HashMap实现，无序TreeSet：二叉树实现LinkHashSet：HashMap实现数据存储，双向链表记录顺序MapHashMap：数组+链表存储数据，线程不安全ConcurrentHashMap：分段锁实现，线程安全**HashTable：线程安全**TreeMap：基于二叉树数据结构LinkedHashMap：基于HashMap数据结构，使用链表保存插入顺序异常反射内部类泛型
java集合(Collection List Set Map)万字详解
weixin_45996580的博客
10-01 335
java 集合详解 如有错误好请指正（持续更新中） 下面是集合的关系图 目录 Collection 集合与数组的比较 Collection 接口中的方法 Collection 方法实例 List List 接口中的方法 ArrayList ArrayList的常用方法实现 ArrayList的源码解析链接 LinkedList LinkedLsit的扩容方式 Vector Vector的常用方法 Vector的子类 Stack List的总结 Set HashSet TreeSet
Java集合类：Set、List、Map、Queue 详解
CHANGE ING的博客
09-04 602
Java集合类: Set、List、Map、Queue使用场景梳理 相关学习资料 http://files.cnblogs.com/LittleHann/java集合排序及java集合类详解(collection、list、map、set).rar http://blog.sina.com.cn/s/blog_a345a8960101k9vx.html http://f51889920.iteye...
JAVA集合（含List、Map、Set）（超详细版）
rc1596919047的博客
06-09 2万+
java集合可分为Set、List、Queue和Map四种体系。set代表无序、不可重复的集合List代表有序、重复的集合而Map则代表具有映射关系的集合Queue代表一种队列集合实现Java集合就像是一种容器，可以把多个对象（实际上是对象的引用，但习惯上都称对象）“丢进”该容器中。从Java5 增加了泛型以后，Java集合可以记住容器中对象的数据类型，使得编码更加简洁、健壮。2.集合和数组的区别长度区别：数组的长度固定，而集合长度可变。
java list map 查询_Java集合List、Set以及Map详解
weixin_42394913的博客
02-16 603
一、集合1.1、概念：是对象的容器，实现了对于对象常用的操作，可实现数组的功能1.2、集合与数组的区别数组长度固定，集合长度不固定数组可以存储基本类型和引用类型，而集合只能存储引用类型1.3、概述List、Set、Map都是接口，其中List和Set继承Collection接口，Map为独立接口List的实现类有ArrayList(重要)、LinkedList(重要)、VectorSet的实现类有...
Java集合框架详解：Set, List, Map, Queue
本摘要将深入探讨Java集合的主要组成部分：Set、List、Map和Queue四大体系，并分析它们的特点、接口和常用实现类。 Set接口是Java集合框架的一个重要组成部分，它不允许重复元素的存在。Set接口的实现类如HashSet，...
java之集合（详细-Map,Set,List）
weixin_42242910的博客
12-11 1759
TreeSet集合存储自定义类型的对象时，必须指定排序规则，支持如下两种方式来指定比较规则。方式一让自定义的类（如学生类）实现Comparable接口，重写里面的compareTo方法来指定比较规则。方式二通过调用TreeSet集合有参数构造器，可以设置Comparator对象（比较器对象，用于指定比较规则。根据方式一解决对象排序根据方式二解决对象排序注意：如果既用了方式一又用了方式二进行自定义排序，那么TreeSet就近选择自己自带的比较器对象进行排序；
Java集合框架详解：List、Set与Map用法
Java-day-9 的主题围绕 Java 集合框架展开，重点讲解了三种核心集合类型：List（列表）、Set（集）和 Map（映射），分别对应标题中的“收藏清单”、“收藏集”和“收藏图”。这些内容是 Java 编程语言中极为重要的...
车载系统应用开发集成系统API
yangyulong0622的博客
12-16 672
车载开发中，为了快速迭代常将系统应用剥离为普通应用开发，但调用系统API时反射效率低。解决方法是通过集成framework.jar，但会遇到编译报错问题。通用方案是在gradle中配置bootstrapClasspath引入jar包。当使用高版本JDK时，必须强制指定模块使用JDK8并关闭lint检查才能生效。关键步骤：先加载jar包到工程，再设置模块JDK版本为1.8。
Windows安装Maven
heqilai1的博客
12-17 234
Maven是一个基于POM模型的项目管理和构建自动化工具，其核心是通过一份配置文件，实现依赖管理和标准化的构建流程。对于Java开发者而言，Maven不是一个可选项，而是一个基础设施。它极大地降低了项目管理的复杂度，让开发者可以更专注于编写代码，而不是浪费时间在“搭建环境”和“寻找Jar包”上，Maven因其稳定、成熟和广泛的应用，至今仍是Java生态系统中最主流的构建工具。二、下载Maven https://maven.apache.org/download.cgi。至此Maven安装配置完成 😊😊。
MyBatis-Plus 单元测试中 Lambda Mock 的坑与解决
qq_43657722的博客
12-17 1220
本文总结了 MyBatis-Plus 在单元测试中使用 LambdaWrapper 时常见的 Lambda 缓存异常问题，分析其根源在于 Mock 环境缺失真实上下文。通过精简示例说明为何 any(LambdaWrapper.class) 易出错，并给出使用 any() 的稳定解决方案，强调单元测试应聚焦业务逻辑、避免过度关注 SQL 与 Lambda 细节。
JAVA设计模式之观察者模式
pingguocu3的博客
12-17 384
在我们开发的过程中，经常会遇到一些当什么什么事情发生的时候，然后做什么什么事。比如某种商品的物价上涨时会导致部分商家高兴，而消费者伤心。平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。著作权归作者所有,转载或内容合作请联系作者。
使用idea启动一个springboot项目
最新发布
qq_51389137的博客
12-19 1515
5.装配置maven配置到idea下载项目依赖。4.装navicat。
【信创】中间件对比
zkw54334的博客
12-17 1789
中间件并非“是否替换”的问题，而是**“如何在稳定、成本、可控之间取得最优解”**。在信创背景下，国产中间件已从“可用”迈向“好用”，未来的关键在于规模化落地、生态成熟与工程经验积累。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值