java集合基础必备

路线

第 1 阶段：基础必备

1. Collection 接口通用方法
   • add、remove、clear、contains、size、isEmpty、iterator
2. Iterator 迭代器
   • 遍历集合的标准方式
   • 增强 for 循环
3. List 家族（最重要）
   • ArrayList（动态数组）
   • LinkedList（双向链表）
   • 二者区别、使用场景、底层原理
4. Set 家族
   • HashSet（哈希表）
   • LinkedHashSet（有序）
   • TreeSet（可排序）
   • 去重原理：hashCode () + equals ()

第 2 阶段：Map 集合

1. HashMap
   • 底层结构：数组 + 链表 + 红黑树
   • 哈希冲突
   • put/get 原理
   • 扩容机制
2. LinkedHashMap
   • 保留插入顺序
3. TreeMap
   • 可排序
4. HashMap vs Hashtable vs ConcurrentHashMap

第 3 阶段：进阶知识

1. 集合底层数据结构
   • ArrayList：数组
   • LinkedList：双向链表
   • HashMap：数组 + 链表 + 红黑树
   • HashSet：包装 HashMap
2. 线程安全问题
   • 哪些集合线程不安全？
   • 如何变成安全？
   • CopyOnWriteArrayList
3. 比较器
   • Comparable
   • Comparator
4. Stream 流（Java 8+）
   • 集合过滤、排序、聚合、分组

一、Collection 核心通用方法（所有单列集合都能用）

核心方法清单

• add(E e)：添加单个元素
• remove(Object o)：删除指定元素
• clear()：清空所有元素
• contains(Object o)：判断是否包含元素
• size()：获取集合元素个数
• isEmpty()：判断集合是否为空
• iterator()：获取迭代器

基础示例代码

import java.util.Collection;
import java.util.ArrayList;

public class CollectionDemo {
    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>();
        // 添加
        coll.add("Java");
        coll.add("C++");
        // 判断包含
        System.out.println(coll.contains("Java"));
        // 元素数量
        System.out.println(coll.size());
        // 删除
        coll.remove("C++");
        // 判空
        System.out.println(coll.isEmpty());
        // 清空
        coll.clear();
    }
}

---

二、Iterator 迭代器 + 增强 for

1. 迭代器核心作用

集合通用遍历方式，统一所有单列集合遍历规则，支持遍历中安全删除元素。

核心三步：

1. iterator() 获取迭代器
2. hasNext() 判断是否有下一个元素
3. next() 获取下一个元素

迭代器代码示例

Collection<String> coll = new ArrayList<>();
coll.add("A");
coll.add("B");

// 迭代器遍历
Iterator<String> it = coll.iterator();
while (it.hasNext()){
    String str = it.next();
    System.out.println(str);
}

2. 增强 for 循环

• 底层：本质就是迭代器，语法简化
• 限制：遍历过程中不能增删元素，会触发并发修改异常

// 增强for
for (String s : coll) {
    System.out.println(s);
}

关键考点

• 并发修改异常：ConcurrentModificationException
• 增强 for 适合纯遍历，迭代器适合需要删除元素的场景

---

三、List 家族（有序、可重复、有索引）

共性特点

1. 存入顺序 = 取出顺序（有序）
2. 元素可重复
3. 拥有索引，支持根据索引增删改查

1. ArrayList

• 底层：动态扩容数组
• 优点：查询、遍历极快（随机访问）
• 缺点：增删元素需要移动数组，效率低
• 默认初始容量：10，扩容机制：原容量 1.5 倍

2. LinkedList

• 底层：双向链表
• 优点：首尾增删元素效率极高，无需移动数据
• 缺点：随机查询慢，需要从头 / 尾逐个遍历
• 额外实现了 Deque，可做栈、队列使用

3. 核心区别 & 使用场景

集合	底层	查询	增删	适用场景
ArrayList	动态数组	快	慢	大量查询、遍历
LinkedList	双向链表	慢	快	频繁增删、头尾操作

---

四、Set 家族（无序 / 唯一、不可重复、无普通索引）

共性特点

1. 元素不可重复
2. 无索引，不能通过下标获取元素
3. 只能用迭代器 / 增强 for 遍历

1. HashSet

• 底层：HashMap 哈希表
• 特点：无序、去重、存取速度快
• 去重核心规则：
  1. 先调用 hashCode() 计算哈希值
  2. 哈希值不同 → 直接判定为不同元素
  3. 哈希值相同 → 再调用 equals() 比较内容
  4. 两者都相同 → 判定重复，拒绝存入

2. LinkedHashSet

• 底层：哈希表 + 双向链表
• 特点：去重 + 保留插入顺序
• 适用：需要去重，又要保证顺序的场景

3. TreeSet

• 底层：红黑树
• 特点：自动自然排序、去重
• 排序规则：
  • 元素实现 Comparable 接口（自然排序）
  • 或创建集合时传入 Comparator 比较器

Set 去重原理

自定义对象（实体类）想要 HashSet 去重，必须重写：hashCode() + equals()

只重写其中一个，无法实现完整去重。

Set<String> hashSet = new HashSet<>();
hashSet.add("1");
hashSet.add("1"); // 重复元素，自动舍弃

Set<String> linkedHashSet = new LinkedHashSet<>();
Set<Integer> treeSet = new TreeSet<>(); // 自动升序排序