第 12 章 集合
第 12 章 集合
12.12 Map 接口和常用方法
12.12.1 Map 接口实现类的特点 [很实用]
注意： 这里讲的是 JDK8 的 Map 接口特点 Map.java
- Map 与 Collection 并列存在，用于保存具有映射关系的数据（Key-Value）
- Map 中的
key和value可以是任何引用类型的数据，会封装到HashMap$Node对象中 - Map 中的
key不允许重复，原因和HashSet一样（前面分析过源码） - Map 中的
value可以重复 - Map 的
key可以为null，value也可以为null；注意key为null时只能有一个，value为null时可以多个 - 常用
String类作为 Map 的key key和value之间存在单向一对一关系，即通过指定的key总能找到对应的value
public class Map_ {
public static void main(String[] args) {
//解读Map 接口实现类的特点, 使用实现类HashMap
//1. Map与Collection并列存在。用于保存具有映射关系的数据:Key-Value(双列元素)
//2. Map 中的 key 和 value 可以是任何引用类型的数据，会封装到HashMap$Node 对象中
//3. Map 中的 key 不允许重复，原因和HashSet 一样，前面分析过源码.
//4. Map 中的 value 可以重复
//5. Map 的key 可以为 null, value 也可以为null ，注意 key 为null,
// 只能有一个，value 为null ,可以多个
//6. 常用String类作为Map的 key
//7. key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到对应的 value
Map map = new HashMap();
map.put("no1", "韩顺平");//k-v
map.put("no2", "张无忌");//k-v
map.put("no1", "张三丰");//当有相同的k , 就等价于替换.
map.put("no3", "张三丰");//k-v
map.put(null, null); //k-v
map.put(null, "abc"); //等价替换
map.put("no4", null); //k-v
map.put("no5", null); //k-v
map.put(1, "赵敏");//k-v
map.put(new Object(), "金毛狮王");//k-v
// 通过get 方法，传入 key ,会返回对应的value
System.out.println(map.get("no2"));//张无忌
System.out.println("map=" + map);
}
}
public class MapMethod {
public static void main(String[] args) {
//演示map接口常用方法
Map map = new HashMap();
map.put("邓超", new Book("", 100));//OK
map.put("邓超", "孙俪");//替换-> 一会分析源码
map.put("王宝强", "马蓉");//OK
map.put("宋喆", "马蓉");//OK
map.put("刘令博", null);//OK
map.put(null, "刘亦菲");//OK
map.put("鹿晗", "关晓彤");//OK
map.put("hsp", "hsp的老婆");
System.out.println("map=" + map);
// remove:根据键删除映射关系
map.remove(null);
System.out.println("map=" + map);
// get：根据键获取值
Object val = map.get("鹿晗");
System.out.println("val=" + val);
// size:获取元素个数
System.out.println("k-v=" + map.size());
// isEmpty:判断个数是否为0
System.out.println(map.isEmpty());//F
// clear:清除k-v
//map.clear();
System.out.println("map=" + map);
// containsKey:查找键是否存在
System.out.println("结果=" + map.containsKey("hsp"));//T
}
}
class Book {
private String name;
private int num;
public Book(String name, int num) {
this.name = name;
this.num = num;
}
}
12.12.3 Map 接口遍历方法
Map遍历方式案例演示
MapFor.java
containsKey：查找键是否存在keySet：获取所有的键entrySet：获取所有关系 k-vvalues：获取所有的值
public class MapFor {
public static void main(String[] args) {
Map map = new HashMap();
map.put("邓超", "孙俪");
map.put("王宝强", "马蓉");
map.put("宋喆", "马蓉");
map.put("刘令博", null);
map.put(null, "刘亦菲");
map.put("鹿晗", "关晓彤");
//第一组: 先取出 所有的Key , 通过Key 取出对应的Value
Set keyset = map.keySet();
//(1) 增强for
System.out.println("-----第一种方式-------");
for (Object key : keyset) {
System.out.println(key + "-" + map.get(key));
}
//(2) 迭代器
System.out.println("----第二种方式--------");
Iterator iterator = keyset.iterator();
while (iterator.hasNext()) {
Object key = iterator.next();
System.out.println(key + "-" + map.get(key));
}
//
// //第二组: 把所有的values取出
// Collection values = map.values();
// //这里可以使用所有的Collections使用的遍历方法
// //(1) 增强for
// System.out.println("---取出所有的value 增强for----");
// for (Object value : values) {
// System.out.println(value);
// }
//
//
// //(2) 迭代器
// System.out.println("---取出所有的value 迭代器----");
// Iterator iterator2 = values.iterator();
// while (iterator2.hasNext()) {
// Object value = iterator2.next();
// System.out.println(value);
//
// }
//
// //第三组: 通过EntrySet 来获取 k-v
Set entrySet = map.entrySet();// EntrySet<Map.Entry<K,V>>
// //(1) 增强for
System.out.println("----使用EntrySet 的 for增强(第3种)----");
for (Object entry : entrySet) {
//将entry 转成 Map.Entry
Map.Entry m = (Map.Entry) entry;
System.out.println(m.getKey() + "-" + m.getValue());
}
//(2) 迭代器
System.out.println("----使用EntrySet 的 迭代器(第4种)----");
Iterator iterator3 = entrySet.iterator();
while (iterator3.hasNext()) {
Object entry = iterator3.next();
//System.out.println(next.getClass());//HashMap$Node -实现-> Map.Entry (getKey,getValue)
//向下转型 Map.Entry
Map.Entry m = (Map.Entry) entry;
System.out.println(m.getKey() + "-" + m.getValue());
}
Map<Integer,Integer> cnt = new HashMap<>();
cnt.put(1,1);
cnt.put(2,2);
for(Map.Entry<Integer,Integer> entry :cnt.entrySet()){
System.out.println(entry.getKey() + "-" + entry.getValue());
}
}
}
12.12.4Map接口课堂练习
public class MapExercise {
public static void main(String[] args) {
//完成代码
Map hashMap = new HashMap();
//添加对象
hashMap.put(1, new Emp("jack", 300000, 1));
hashMap.put(2, new Emp("tom", 21000, 2));
hashMap.put(3, new Emp("milan", 12000, 3));
//遍历2种方式
//并遍历显示工资>18000的员工(遍历方式最少两种)
//1. 使用keySet -> 增强for
Set keySet = hashMap.keySet();
System.out.println("====第一种遍历方式====");
for (Object key : keySet) {
//先获取value
Emp emp = (Emp) hashMap.get(key);
if(emp.getSal() >18000) {
System.out.println(emp);
}
}
//2. 使用EntrySet -> 迭代器
// 体现比较难的知识点
// 慢慢品，越品越有味道.
Set entrySet = hashMap.entrySet();
System.out.println("======迭代器======");
Iterator iterator = entrySet.iterator();
while (iterator.hasNext()) {
Map.Entry entry = (Map.Entry)iterator.next();
//通过entry 取得key 和 value
Emp emp = (Emp) entry.getValue();
if(emp.getSal() > 18000) {
System.out.println(emp);
}
}
}
}
/**
* 使用HashMap添加3个员工对象，要求
* 键：员工id
* 值：员工对象
*
* 并遍历显示工资>18000的员工(遍历方式最少两种)
* 员工类：姓名、工资、员工id
*/
class Emp {
private String name;
private double sal;
private int id;
public Emp(String name, double sal, int id) {
this.name = name;
this.sal = sal;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getSal() {
return sal;
}
public void setSal(double sal) {
this.sal = sal;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public String toString() {
return "Emp{" +
"name='" + name + '\'' +
", sal=" + sal +
", id=" + id +
'}';
}
}
12.13 Map 接口实现类 - HashMap
12.13.1 HashMap 小结
- Map 接口的常用实现类：HashMap、Hashtable 和 Properties。
- HashMap 是 Map 接口使用频率最高的实现类。
- HashMap 是以 key-val 对的方式来存储数据（HashMap$Node 类型）[案例 Entry]
- key 不能重复，但是值可以重复，允许使用 null 键和 null 值。
- 如果添加相同的 key，则会覆盖原来的 key-val，等同于修改。（key 不会替换，val 会替换）
- 与 HashSet 一样，不保证映射的顺序，因为底层是以 hash 表的方式来存储的。（jdk8 的 hashMap 底层 数组 + 链表 + 红黑树）
- HashMap 没有实现同步，因此是线程不安全的，方法没有做同步互斥的操作，没有 synchronized
12.13.2 HashMap 底层机制及源码剖析
12.13.3 HashMap 底层机制及源码剖析
HashMapSource.java 先说结论-> debug 源码.
扩容机制 [和 HashSet 相同]
- HashMap 底层维护了
Node类型的数组table，默认为null - 当创建对象时，将加载因子(
loadfactor)初始化为0.75 - 当添加
key-val时，通过key的哈希值得到在table的索引。然后判断该索引处是否有元素：- 无元素：直接添加
- 有元素：继续判断该元素的
key和准备加入的key是否相等- 相等：直接替换
val - 不相等：判断是树结构还是链表结构，做出相应处理
- 相等：直接替换
- 容量不够：扩容
- 第 1 次添加，扩容
table容量为16，临界值(threshold)为12（16*0.75） - 后续扩容，
table容量变为原来的2倍（如32），临界值也变为原来的2倍（如24），依次类推 - Java8 中，若一条链表元素个数超过
TREEIFY_THRESHOLD（默认8），且table大小>= MIN_TREEIFY_CAPACITY（默认64），会进行树化（转红黑树 ）
public class HashMapSource1 {
public static void main(String[] args) {
HashMap map = new HashMap();
map.put("java", 10);//ok
map.put("php", 10);//ok
map.put("java", 20);//替换value
System.out.println("map=" + map);//
/*解读HashMap的源码+图解
1. 执行构造器 new HashMap()
初始化加载因子 loadfactor = 0.75
HashMap$Node[] table = null
2. 执行put 调用 hash方法，计算 key的 hash值 (h = key.hashCode()) ^ (h >>> 16)
public V put(K key, V value) {//K = "java" value = 10
return putVal(hash(key), key, value, false, true);
}
3. 执行 putVal
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;//辅助变量
//如果底层的table 数组为null, 或者 length =0 , 就扩容到16
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//取出hash值对应的table的索引位置的Node, 如果为null, 就直接把加入的k-v
//, 创建成一个 Node ,加入该位置即可
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;//辅助变量
// 如果table的索引位置的key的hash相同和新的key的hash值相同，
// 并 满足(table现有的结点的key和准备添加的key是同一个对象 || equals返回真)
// 就认为不能加入新的k-v
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)//如果当前的table的已有的Node 是红黑树，就按照红黑树的方式处理
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//如果找到的结点，后面是链表，就循环比较
for (int binCount = 0; ; ++binCount) {//死循环
if ((e = p.next) == null) {//如果整个链表，没有和他相同,就加到该链表的最后
p.next = newNode(hash, key, value, null);
//加入后，判断当前链表的个数，是否已经到8个，到8个，后
//就调用 treeifyBin 方法进行红黑树的转换
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash && //如果在循环比较过程中，发现有相同,就break,就只是替换value
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value; //替换，key对应value
afterNodeAccess(e);
return oldValue;
}
}
++modCount;//每增加一个Node ,就size++
if (++size > threshold[12-24-48])//如size > 临界值，就扩容
resize();
afterNodeInsertion(evict);
return null;
}
5. 关于树化(转成红黑树)
//如果table 为null ,或者大小还没有到 64，暂时不树化，而是进行扩容.
//否则才会真正的树化 -> 剪枝
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
}
*/
}
HashMapSource2.java
模拟 HashMap 触发扩容、树化情况，并 Debug 验证。
public class HashMapSource2 {
public static void main(String[] args) {
HashMap hashMap = new HashMap(64);
for(int i = 1; i <= 12; i++) {
hashMap.put(new A(i), "hello");
// hashMap.put(i, "hello");
}
hashMap.put("aaa", "bbb");
System.out.println("hashMap=" + hashMap);//12个 k-v
//布置一个任务，自己设计代码去验证，table 的扩容
//0 -> 16(12) -> 32(24) -> 64(64*0.75=48)-> 128 (96) ->
//自己设计程序，验证-》 增强自己阅读源码能力. 看别人代码.
}
}
class A {
private int num;
public A(int num) {
this.num = num;
}
//所有的A对象的hashCode都是100
@Override
public int hashCode() {
return 100;
}
@Override
public String toString() {
return "\nA{" +
"num=" + num +
'}';
}
}
12.14 Map 接口实现类 - Hashtable
12.14.1 HashTable 的基本介绍
- 存储结构：存放键值对（K-V）
- null 限制：键和值都不能为
null，否则抛出NullPointerException - 使用方式：用法与
HashMap基本一致 - 线程安全：
HashTable是线程安全的（方法带synchronized），HashMap线程不安全 - 底层结构：与
HashMap类似（数组 + 链表等，JDK8 后也有树化逻辑 ）
代码验证示例（HashTableExercise.java）：
Hashtable table = new Hashtable();//ok
table.put("john", 100); //ok
table.put(null, 100); // 异常（键为 null 不允许）
table.put("john", null);// 异常（值为 null 不允许）
table.put("lucy", 100); //ok
table.put("lic", 100); //ok
table.put("lic", 88); // 替换值（键重复时覆盖）
System.out.println(table);
12.14.2 Hashtable 和 HashMap 对比
| 特性 | HashMap | Hashtable |
|---|---|---|
| JDK 版本 | 1.2 | 1.0 |
| 线程安全 | 不安全 | 安全（同步） |
| 效率 | 高 | 较低 |
| null 允许 | 键/值均可为 null（键仅 1 个 null） | 不允许 |
12.15 Map 接口实现类 - Properties
12.15.1 基本介绍
- 继承关系：继承
Hashtable并实现Map接口，以键值对（K-V）形式存储数据 - 使用场景：常用于读取
.properties配置文件（如xxx.properties），加载数据到Properties对象后读取/修改 - 典型流程：从配置文件加载 → 操作键值 → 持久化回文件，常作为系统配置管理方案
12.15.2 基本使用
public class Properties_ {
public static void main(String[] args) {
//解读
//1. Properties 继承 Hashtable
//2. 可以通过 k-v 存放数据，当然key 和 value 不能为 null
//增加
Properties properties = new Properties();
//properties.put(null, "abc");//抛出 空指针异常
//properties.put("abc", null); //抛出 空指针异常
properties.put("john", 100);//k-v
properties.put("lucy", 100);
properties.put("lic", 100);
properties.put("lic", 88);//如果有相同的key ， value被替换
System.out.println("properties=" + properties);
//通过k 获取对应值
System.out.println(properties.get("lic"));//88
//删除
properties.remove("lic");
System.out.println("properties=" + properties);
//修改
properties.put("john", "约翰");
System.out.println("properties=" + properties);
}
}
12.16 TreeSet & TreeMap 核心要点梳理
12.16.1TreeSet 核心逻辑
- 底层依赖与排序机制
TreeSet 底层基于 TreeMap 实现，利用红黑树（自平衡二叉搜索树）维护元素顺序，支持两种排序模式：
- 自然排序：元素实现
Comparable接口，按compareTo规则排序（如String按字典序）。 - 定制排序：通过构造器传入
Comparator自定义排序规则，优先级高于自然排序。
- 关键代码示例（定制排序）
TreeSet treeSet = new TreeSet(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
// 按字符串长度排序（短 → 长）
return ((String) o1).length() - ((String) o2).length();
}
});
treeSet.add("jack"); // 4
treeSet.add("tom"); // 3
treeSet.add("sp"); // 2
treeSet.add("a"); // 1
treeSet.add("abc"); // 3
// 输出：[a, sp, tom, abc, jack]（按长度排序，长度相同时按自然序）
System.out.println("treeSet=" + treeSet);
- 源码关键流程（结合 TreeMap）
TreeSet 的add操作最终调用 TreeMap 的put方法：
- 排序规则传递：构造 TreeSet 时传入的
Comparator，会赋值给 TreeMap 的comparator属性。 - 插入逻辑：
- 若
Comparator不为空，遍历红黑树节点，通过comparator.compare(key, t.key)确定插入位置。 - 若比较结果
cmp = 0，视为重复元素，不插入；否则根据cmp大小插入左子树（cmp < 0）或右子树（cmp > 0）。
- 若
12.16.2TreeMap 核心逻辑
- 底层结构与排序机制
TreeMap 底层基于 红黑树 实现，键（Key）需支持排序：
- 自然排序：Key 实现
Comparable接口，按compareTo排序。 - 定制排序：构造器传入
Comparator，自定义排序规则，直接决定 Key 的存储顺序。
- 关键代码示例（定制排序）
TreeMap treeMap = new TreeMap(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
// 按字符串长度倒序排序（长 → 短）
return ((String) o2).length() - ((String) o1).length();
}
});
treeMap.put("jack", "杰克"); // 4
treeMap.put("tom", "汤姆"); // 3
treeMap.put("kristina", "克瑞斯提诺"); // 8
treeMap.put("smith", "斯密斯"); // 5
treeMap.put("hsp", "韩顺平"); // 3（因长度与 "tom" 相同，且比较规则下视为重复，无法插入）
// 输出：{kristina=克瑞斯提诺, smith=斯密斯, jack=杰克, tom=汤姆}（按长度倒序）
System.out.println("treemap=" + treeMap);
- 源码关键流程
TreeMap 的put方法核心逻辑：
- 初始化红黑树：首次
put时，直接创建根节点Entry。 - 遍历红黑树：若传入
Comparator（cpr != null），循环比较新 Key 与当前节点 Key：cmp < 0：向左子树遍历；cmp > 0：向右子树遍历；cmp = 0：替换当前节点值（视为 Key 重复，不新增节点）。
- 维护红黑树平衡：插入新节点后，通过旋转、变色操作恢复红黑树性质（保证 O(log n) 复杂度）。
12.16.3TreeSet vs TreeMap 核心差异
| 对比项 | TreeSet | TreeMap |
|---|---|---|
| 存储形式 | 仅存元素（Key），基于 TreeMap 封装 | 存储键值对（Key-Value） |
| 排序对象 | 元素本身（Key） | 显式定义的 Key |
| 典型场景 | 需有序去重的集合（如词汇表排序） | 需有序关联映射的场景（如配置表） |
| 底层依赖 | 完全依赖 TreeMap（Key 存储，Value 占位） | 直接基于红黑树实现 |
12.16.4核心设计思想总结
- 红黑树的价值：通过自平衡机制，保证插入、查询、删除的时间复杂度稳定在 O(log n)，避免普通二叉搜索树退化（如链表化导致 O(n) 复杂度）。
- 排序的灵活性：支持
Comparable（自然排序）和Comparator（定制排序），覆盖“类默认排序”与“场景化排序”需求。 - TreeSet 的本质：TreeMap 的“Key 集合视图”，利用 TreeMap 的排序能力实现元素有序存储，简化有序集合的使用成本。
通过理解红黑树的底层支撑与排序规则的传递逻辑，可清晰掌握 TreeSet/TreeMap 的有序性实现，灵活应对“需按自定义规则排序”的业务场景（如按字符串长度、对象属性等排序）。
12.17 总结-开发中如何选择集合实现类(记住)
在开发中，选择集合实现类主要看业务操作特点，结合集合特性选，分析流程：
- 判断存储类型：是存一组对象（单列）还是一组键值对（双列）
- 一组对象（单列）→ Collection 接口
- 允许重复 → List
- 增删多：选
LinkedList（底层双向链表） - 改查多：选
ArrayList（底层可变对象数组）
- 增删多：选
- 不允许重复 → Set
- 无序：选
HashSet（底层基于HashMap，哈希表结构：数组+链表+红黑树 ） - 排序：选
TreeSet（需实现排序规则，如Comparable/Comparator） - 插入&取出顺序一致：选
LinkedHashSet（维护数组+双向链表，保证顺序 ）
- 无序：选
- 允许重复 → List
- 一组键值对（双列）→ Map
- 键无序：选
HashMap（底层哈希表，JDK7 数组+链表；JDK8 数组+链表+红黑树 ） - 键排序：选
TreeMap（按键排序，需实现排序规则 ） - 键插入&取出顺序一致：选
LinkedHashMap（维护链表记录顺序 ） - 读取配置文件：选
Properties（继承Hashtable，专用于.properties文件读写 ）
- 键无序：选
按业务需求（增删/改查频率、是否需顺序/排序、是否键值对等），匹配对应集合即可。
12.18 Collections 工具类
12.18.1 Collections 工具类介绍
- Collections 是操作 Set、List、Map 等集合的工具类
- 提供一系列静态方法，用于集合元素的排序、查询、修改等操作
12.18.2 排序操作（均为 static 方法）
-
reverse(List)：反转 List 中元素顺序 -
shuffle(List)：随机打乱 List 元素顺序 -
sort(List)：按元素自然顺序对 List 升序排序（需元素实现Comparable） -
sort(List, Comparator)：按指定Comparator规则对 List 排序 -
swap(List, int, int)：交换 List 中指定索引i和j处的元素 -
应用案例演示：
Collections.java
public class Collections_ {
public static void main(String[] args) {
//创建ArrayList 集合，用于测试.
List list = new ArrayList();
list.add("tom");
list.add("smith");
list.add("king");
list.add("milan");
list.add("tom");
// reverse(List)：反转 List 中元素的顺序
Collections.reverse(list);
System.out.println("list=" + list);
// shuffle(List)：对 List 集合元素进行随机排序
// for (int i = 0; i < 5; i++) {
// Collections.shuffle(list);
// System.out.println("list=" + list);
// }
// sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
Collections.sort(list);
System.out.println("自然排序后");
System.out.println("list=" + list);
// sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
//我们希望按照 字符串的长度大小排序
Collections.sort(list, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
//可以加入校验代码.
return ((String) o2).length() - ((String) o1).length();
}
});
System.out.println("字符串长度大小排序=" + list);
// swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
//比如
Collections.swap(list, 0, 1);
System.out.println("交换后的情况");
System.out.println("list=" + list);
//Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
System.out.println("自然顺序最大元素=" + Collections.max(list));
//Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
//比如，我们要返回长度最大的元素
Object maxObject = Collections.max(list, new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return ((String)o1).length() - ((String)o2).length();
}
});
System.out.println("长度最大的元素=" + maxObject);
//Object min(Collection)
//Object min(Collection，Comparator)
//上面的两个方法，参考max即可
//int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
System.out.println("tom出现的次数=" + Collections.frequency(list, "tom"));
//void copy(List dest,List src)：将src中的内容复制到dest中
ArrayList dest = new ArrayList();
//为了完成一个完整拷贝，我们需要先给dest 赋值，大小和list.size()一样
for(int i = 0; i < list.size(); i++) {
dest.add("");
}
//拷贝
Collections.copy(dest, list);
System.out.println("dest=" + dest);
//boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值
//如果list中，有tom 就替换成 汤姆
Collections.replaceAll(list, "tom", "汤姆");
System.out.println("list替换后=" + list);
}
}
12.18.3 排序操作
（均为 static 方法）
应用案例演示
12.18.4 查找、替换
Object max(Collection)：按元素自然顺序，返回集合最大元素Object max(Collection, Comparator)：按Comparator规则，返回集合最大元素Object min(Collection)：返回集合最小元素（自然顺序）Object min(Collection, Comparator)：按Comparator规则，返回集合最小元素int frequency(Collection, Object)：返回集合中指定元素的出现次数void copy(List dest, List src)：把src内容复制到dest（需dest容量 ≥src）boolean replaceAll(List list, Object oldVal, Object newVal)：用newVal替换list里所有oldVal
12.19 Java 集合去重与代码分析题目整理
12.19.1简答题：HashSet 和 TreeSet 如何实现去重
题目内容
试分析 HashSet 和 TreeSet 分别如何实现去重
答案与解释
1. HashSet 去重机制
HashSet 基于 HashMap 实现（底层用 HashMap 存储元素，Value 固定为一个占位对象），去重依赖 hashCode() + equals()：
- 存储元素时，先调用对象的
hashCode()计算哈希值，根据哈希值找到HashMap中对应的桶（数组索引）。 - 若桶为空，直接存入元素。
- 若桶不为空，遍历桶中已存在的元素，依次调用
equals()比较：- 若
equals()返回true，视为重复元素，不存入； - 若
equals()返回false，视为不同元素，存入桶中（链表或红黑树，根据情况转换 ）。
- 若
2. TreeSet 去重机制
TreeSet 基于 TreeMap 实现（底层用 TreeMap 存储元素，Value 固定为一个占位对象），去重依赖 排序规则（Comparator 或 Comparable）：
- 若创建 TreeSet 时传入
Comparator（定制排序），则通过Comparator.compare(Object o1, Object o2)比较元素：- 若返回
0，视为重复元素，不存入； - 若返回非
0，视为不同元素，按排序规则插入红黑树。
- 若返回
- 若未传入
Comparator，则要求元素实现Comparable接口，通过Comparable.compareTo(Object o)比较：- 若返回
0，视为重复元素，不存入； - 若返回非
0，视为不同元素，按自然排序插入红黑树。
- 若返回
12.19.2 代码分析题 1：TreeSet 添加自定义对象是否抛异常
题目内容
下面代码运行会不会抛出异常，并从源码层面说明原因（考察读源码 + 接口编程 + 动态绑定）：
TreeSet treeSet = new TreeSet();
treeSet.add(new Person());
答案与解释
会抛出 ClassCastException 异常，原因如下：
TreeSet 底层依赖 TreeMap，而 TreeMap 要求 Key 必须支持排序（要么实现 Comparable 接口，要么创建时传入 Comparator）。
-
源码关键逻辑：
TreeMap 的put方法中，若未传入Comparator，会尝试将 Key 强转为Comparable类型，并调用compareTo方法：if (cpr == null) { if (key == null) throw new NullPointerException(); @SuppressWarnings("unchecked") Comparable<? super K> k = (Comparable<? super K>) key; do { // ... 遍历红黑树，调用 k.compareTo(...) } while (t != null); } -
异常触发条件：
若Person类未实现Comparable接口，强转Comparable会失败，抛出ClassCastException（运行时异常）。
12.19.3 代码分析题 2：HashSet 元素操作后的输出结果
题目内容
已知：Person 类按照 id 和 name 重写了 hashCode 和 equals 方法，问下面代码输出什么？
HashSet set = new HashSet();
Person p1 = new Person(1001, "AA");
Person p2 = new Person(1002, "BB");
set.add(p1);
set.add(p2);
p1.name = "CC";
set.remove(p1);
System.out.println(set); // 输出 1
set.add(new Person(1001, "CC"));
System.out.println(set); // 输出 2
set.add(new Person(1001, "AA"));
System.out.println(set); // 输出 3
答案与解释
需结合 HashSet 去重逻辑 和 对象属性修改的影响 分析：
-
初始状态（添加
p1、p2）
set.add(p1)和set.add(p2)后，set中有两个元素：Person(1001, "AA")、Person(1002, "BB")。 -
修改
p1.name并调用set.remove(p1)
p1的name被修改为"CC"，但HashSet底层HashMap的哈希桶是根据插入时的hashCode确定的。- 调用
set.remove(p1)时，先计算p1当前的hashCode（基于id=1001、name="CC"），找到对应的哈希桶。 - 遍历桶中元素，调用
equals比较：- 原
p1（id=1001、name="AA"）已被修改为name="CC"，但HashSet中存储的元素是修改前的p1吗？不，p1是同一个对象，修改其属性后，hashCode和equals结果会变化。 - 实际逻辑：
remove(p1)会根据当前p1的hashCode和equals找元素。由于p1的name已改为"CC"，与HashSet中存储的原p1（name="AA"时的状态）的equals比较会返回false（因为name不同），因此 无法删除原p1。
- 原
此时 set 仍包含：Person(1001, "CC")（原 p1，但属性已改）、Person(1002, "BB")？
不，实际 HashSet 中存储的是对象引用，p1 被修改后，HashSet 中对应的元素属性也会变。但 remove 逻辑因 equals 比较失败，无法删除，所以 set 此时仍有 2 个元素：p1（name="CC"）、p2。
但严格来说，HashSet 的 remove 是根据对象当前状态的 hashCode 和 equals 判断的。由于 p1 修改后 hashCode 变化（假设 hashCode 依赖 name），原哈希桶位置可能改变，导致 remove 无法找到正确的元素，最终 set 仍保留 p1（修改后）和 p2，System.out.println(set) 输出 [Person(1001, CC), Person(1002, BB)]（假设 Person 的 toString 输出属性 ）。
- 添加
new Person(1001, "CC")
新对象Person(1001, "CC")的hashCode和equals（与p1比较）：
hashCode相同（id=1001、name="CC"）。equals返回true（属性相同）。
但 HashSet 中已有 p1（name="CC"），因此 新对象无法插入，set 仍为 2 个元素。
- 添加
new Person(1001, "AA")
新对象Person(1001, "AA")的hashCode和equals（与p1比较）：
hashCode不同（name不同）。equals返回false（name不同）。
因此 新对象会被插入，set 变为 3 个元素：p1（name="CC"）、p2、Person(1001, "AA")。
最终输出总结（假设 Person 重写 toString 输出 id 和 name）
System.out.println(set);→[Person(1001, CC), Person(1002, BB)]System.out.println(set);→[Person(1001, CC), Person(1002, BB)]（添加new Person(1001, "CC")失败 ）System.out.println(set);→[Person(1001, CC), Person(1002, BB), Person(1001, AA)]
关键坑点
修改 HashSet 中已存对象的属性（影响 hashCode 或 equals），会导致后续 remove、contains 等操作异常，因为哈希桶位置和比较逻辑已被破坏。避免在存入集合后修改对象的关键属性（或确保修改后重新插入、删除旧对象 ）。
以上题目覆盖了 HashSet、TreeSet 的核心去重逻辑，以及集合操作中对象属性修改的影响，需结合源码和接口实现深入理解。
浙公网安备 33010602011771号