集合的定义
Java 集合是用于存储、操作和管理多个对象的容器框架，它封装并实现了各种常见的数据结构（如数组、链表、哈希表、树等），提供了统一的接口和丰富的操作方法，简化了数据的处理过程。
与数组相比，集合具有动态扩容、类型多样、操作便捷等特点，是 Java 编程中处理多元素数据的核心工具。
集合体系关系图（简化）
HashMap、HashSet
数据结构
HashMap：基于哈希表（数组 + 链表 / 红黑树）实现。数组称为哈希桶，每个桶中存储键值对节点。当链表长度超过阈值（默认 8）时，会转换为红黑树以提高查询效率；当红黑树节点数少于 6 时，会退化为链表。
HashSet：底层基于 HashMap 实现，其存储的元素作为 HashMap 的 key，而 value 是一个固定的 Object 对象（PRESENT）。因此 HashSet 的特性完全由 HashMap 决定。
扩容机制
HashMap：
初始容量默认为 16，负载因子默认为 0.75。当元素数量超过容量 × 负载因子时，会触发扩容。
扩容时，新容量为原容量的 2 倍，然后重新计算所有元素的哈希值并迁移到新的哈希桶中（重新哈希）。
JDK 1.8 中优化了扩容时的元素迁移方式，通过高低位运算减少重新计算哈希的开销。
HashSet：由于底层依赖 HashMap，其扩容机制与 HashMap 一致，跟随底层 HashMap 的扩容而扩容。
检索与插入元素
HashMap：
插入：计算 key 的哈希值，通过哈希值确定存储的桶位置。若桶中已有元素，通过 equals 方法判断是否为相同 key，若相同则替换 value（key 覆盖）；否则插入链表或红黑树中。
检索：根据 key 的哈希值找到对应的桶，然后遍历链表或红黑树，通过 equals 方法匹配 key 以获取 value。
HashSet：
插入：添加元素时，将元素作为 key 存入底层 HashMap，value 为固定对象。若元素已存在（通过 hashCode 和 equals 判断），则不插入（不会发生覆盖，因为 add 方法会返回 false）。
检索：判断元素是否存在时，实际是判断底层 HashMap 中是否存在该 key。
时间复杂度
HashMap：
理想情况下（哈希分布均匀），插入、删除、查询操作的时间复杂度均为 O (1)。
最坏情况下（哈希冲突严重，链表过长），时间复杂度会退化到 O (n)；但转为红黑树后，最坏情况时间复杂度为 O (log n)。
HashSet：由于依赖 HashMap，其添加、删除、查询操作的时间复杂度与 HashMap 一致，同样为 O (1)（理想情况）或 O (log n)（红黑树情况下）。
TreeMap、TreeSet
数据结构
TreeMap：基于红黑树（一种自平衡的二叉搜索树）实现。红黑树的节点按照 key 的自然顺序或自定义比较器的顺序进行排序，保证了元素的有序性。
TreeSet：底层基于 TreeMap 实现，存储的元素作为 TreeMap 的 key，value 是一个固定的 Object 对象（PRESENT）。因此 TreeSet 是有序集合，排序规则与 TreeMap 一致。
扩容机制
TreeMap：红黑树结构没有固定的容量概念，无需像哈希表那样进行扩容。当元素数量增加时，红黑树会通过旋转等操作保持平衡，以维持良好的性能。
TreeSet：由于底层依赖 TreeMap，同样不存在扩容机制，元素的增减通过红黑树的插入和删除操作实现，树结构会自动平衡。
检索与插入元素
TreeMap：
插入：根据 key 的排序规则（自然顺序或比较器）将节点插入红黑树中，插入后会通过旋转和变色操作维持红黑树的平衡。若 key 已存在（通过比较器判断），则会替换其 value（key 覆盖）。
检索：利用二叉搜索树的特性，从根节点开始比较 key，小于当前节点则向左子树查找，大于则向右子树查找，直到找到匹配节点或到达叶子节点。
TreeSet：
插入：添加元素时，将元素作为 key 存入底层 TreeMap，value 为固定对象。若元素已存在（通过比较器判断），则不插入（不会发生覆盖）。
检索：判断元素是否存在时，实际是在底层 TreeMap 的红黑树中进行查找，遵循二叉搜索树的检索逻辑。
时间复杂度
TreeMap：插入、删除、查询操作的时间复杂度均为 O (log n)，这是因为红黑树的高度始终保持在 log n 级别（n 为元素数量）。
TreeSet：由于依赖 TreeMap，其添加、删除、查询操作的时间复杂度与 TreeMap 一致，均为 O (log n)。
代码演示
下面通过 Student 类作为 key 来演示这四个集合的使用，Student 类包含 age 和 name 属性，并重写了 equals、hashCode 方法，实现了 Comparable 接口按 age 排序。
Student 类定义
import java.util.Objects;
// Student类实现Comparable接口，按age排序
public class Student
implements Comparable<
Student> {
private int age;
private String name;
public Student(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public String getName() {
return name;
}
@Override
public String toString() {
return "Student{age=" + age + ", name='" + name + "'}";
}
// 重写equals方法，age和name都相同才认为是同一个对象
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
// 重写hashCode方法，与equals保持一致
@Override
public int hashCode() {
return Objects.hash(age, name);
}
// 实现Comparable接口，按age升序排序
@Override
public int compareTo(Student o) {
return Integer.compare(this.age, o.age);
}
}集合使用演示
import java.util.*;
public class CollectionDemo
{
public static void main(String[] args) {
// 创建测试用的Student对象
Student s1 = new Student(20, "Alice");
Student s2 = new Student(22, "Bob");
Student s3 = new Student(21, "Charlie");
Student s4 = new Student(20, "Alice");
// 与s1是同一个对象(equals返回true)
Student s5 = new Student(23, "David");
Student s6 = new Student(23,"java");
System.out.println("=== HashMap 演示 ===");
HashMap<
Student, String> hashMap = new HashMap<
>();
hashMap.put(s1, "大一");
hashMap.put(s2, "大三");
hashMap.put(s3, "大二");
// 插入s4，与s1是同一个key，会覆盖value
hashMap.put(s4, "大一(重读)");
// 遍历HashMap
for (Map.Entry<
Student, String> entry : hashMap.entrySet()) {
System.out.println(entry.getKey() + " -> " + entry.getValue());
}
System.out.println("\n=== HashSet 演示 ===");
HashSet<
Student> hashSet = new HashSet<
>();
hashSet.add(s1);
hashSet.add(s2);
hashSet.add(s3);
// 插入s4，与s1重复，不会被添加
boolean added = hashSet.add(s4);
System.out.println("s4是否被添加到HashSet: " + added);
// 输出false
// 遍历HashSet
for (Student student : hashSet) {
System.out.println(student);
}
System.out.println("\n=== TreeMap 演示 ===");
TreeMap<
Student, String> treeMap = new TreeMap<
>();
treeMap.put(s1, "大一");
treeMap.put(s2, "大三");
treeMap.put(s3, "大二");
// 插入s4，与s1是同一个age，会保留原来的值，与hashmap相反
treeMap.put(s4, "大一(重读)");
treeMap.put(s5, "大四");
treeMap.put(s6,"大五");
//s5中的age与s6相等,会保留s5
// 遍历TreeMap，会按age升序排列
for (Map.Entry<
Student, String> entry : treeMap.entrySet()) {
System.out.println(entry.getKey() + " -> " + entry.getValue());
}
System.out.println("\n=== TreeSet 演示 ===");
TreeSet<
Student> treeSet = new TreeSet<
>();
treeSet.add(s1);
treeSet.add(s2);
treeSet.add(s3);
// 插入s4，与s1重复，s4不会被添加
added = treeSet.add(s4);
System.out.println("s4是否被添加到TreeSet: " + added);
// 输出false
treeSet.add(s5);
treeSet.add(s6);
// 插入s5，与s6重复，s6不会被加
// 遍历TreeSet，会按age升序排列
for (Student student : treeSet) {
System.out.println(student);
}
}
}
