retainAll方法用于求两个集合的交集，修改调用集合使其仅保留与指定集合共有的元素，基于equals方法判断元素是否相同，会改变原集合内容并返回是否发生修改。
Java集合中的
retainAll方法，说白了，就是用来求两个集合的交集。它会修改调用这个方法的集合，只保留那些同时存在于它自身和作为参数传入的另一个集合中的元素。简单来说，就是“留下共同的朋友”，把那些独有的、对方没有的元素统统移除。这在很多数据过滤和同步的场景下，简直是神来之笔。
解决方案
retainAll方法是
java.util.Collection接口的一部分，所以几乎所有的标准集合类，比如
ArrayList,
HashSet,
LinkedList等，都支持这个操作。它的核心作用是修改当前集合，使其内容变成当前集合与指定集合的交集。
方法的签名是
boolean retainAll(Collection c)。
-
参数
c
: 这是我们要用来进行交集操作的另一个集合。retainAll
会检查当前集合中的每个元素，看它是否也存在于c
中。 -
返回值
boolean
: 如果这个方法执行后，当前集合的内容发生了变化（也就是有元素被移除了），它就返回true
；如果集合没有任何变化（比如两个集合完全相同，或者当前集合是另一个集合的子集），则返回false
。这个返回值其实挺有用的，可以帮助我们判断是否需要进行后续操作。
工作原理和注意事项：
立即学习“Java免费学习笔记（深入）”；
retainAll的内部实现，通常会遍历调用者集合的每个元素，然后用
c.contains(element)来判断这个元素是否应该被保留。如果
contains返回
false，那么这个元素就会从调用者集合中移除。
这里有几个关键点需要注意：
-
基于
equals()
方法: 元素是否“相同”完全取决于它们的equals()
方法。如果你操作的是自定义对象，并且没有正确重写equals()
和hashCode()
方法，那么retainAll
的行为可能就不是你预期的了。它可能会认为两个逻辑上相同的对象是不同的，从而导致错误的交集结果。 -
修改原集合:
retainAll
是一个破坏性操作，它会直接修改调用它的集合。如果你需要保留原始集合，记得先创建一个副本。 -
性能考量:
c.contains(element)
的效率是影响retainAll
整体性能的关键。如果c
是一个HashSet
，contains
操作通常是O(1)
的平均时间复杂度，所以retainAll
会比较快。但如果c
是一个ArrayList
，contains
可能是O(n)
，那么retainAll
的总时间复杂度就可能退化到O(n*m)
（n
是调用者集合大小，m
是c
的大小），这在处理大数据量时会非常慢。 -
异常:
UnsupportedOperationException
: 如果当前集合不支持remove
操作（例如，Collections.unmodifiableList()
返回的列表）。NullPointerException
: 如果参数c
是null
。- 如果集合中包含
null
元素，并且c
不支持null
元素（比如TreeSet
默认情况下），或者c
的contains
方法在处理null
时抛出异常，也可能出现问题。
代码示例：
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class RetainAllDemo {
public static void main(String[] args) {
// 场景一：基本交集操作
List myShoppingList = new ArrayList<>(Arrays.asList("Milk", "Bread", "Eggs", "Coffee", "Sugar"));
List friendsShoppingList = new ArrayList<>(Arrays.asList("Bread", "Juice", "Eggs", "Milk", "Cheese"));
System.out.println("我的购物清单 (原始): " + myShoppingList);
System.out.println("朋友的购物清单: " + friendsShoppingList);
// 找出我们都需要买的东西
boolean changed = myShoppingList.retainAll(friendsShoppingList);
System.out.println("我们共同需要的物品 (我的清单更新后): " + myShoppingList); // [Milk, Bread, Eggs]
System.out.println("我的清单是否改变了? " + changed); // true
// 场景二：利用 Set 优化性能
List allProducts = new ArrayList<>(Arrays.asList(101, 102, 103, 104, 105, 106, 107));
Set availableProductsInStock = new HashSet<>(Arrays.asList(103, 105, 108, 109));
System.out.println("\n所有产品ID: " + allProducts);
System.out.println("库存中可用的产品ID: " + availableProductsInStock);
// 找出当前订单中，库存里也有的产品
boolean stockFiltered = allProducts.retainAll(availableProductsInStock);
System.out.println("订单中且有库存的产品ID: " + allProducts); // [103, 105]
System.out.println("产品列表是否因库存过滤而改变? " + stockFiltered); // true
// 场景三：没有共同元素
List listA = new ArrayList<>(Arrays.asList("Alpha", "Beta"));
List listB = new ArrayList<>(Arrays.asList("Gamma", "Delta"));
System.out.println("\nList A: " + listA);
System.out.println("List B: " + listB);
boolean noCommon = listA.retainAll(listB);
System.out.println("List A (无共同元素后): " + listA); // []
System.out.println("List A 是否改变? " + noCommon); // true (因为它清空了)
}
} retainAll
与 removeAll
有何不同？在性能上又有哪些考量？
这是一个非常常见的问题，也是理解集合操作的关键。
retainAll和
removeAll都是
Collection接口中用于批量修改集合内容的方法，但它们的目的恰好相反：
-
retainAll(Collection c)
: 如前所述，它保留了当前集合中与参数c
集合共同拥有的元素。可以理解为A = A ∩ B
。 -
removeAll(Collection c)
: 它移除了当前集合中所有也存在于参数c
集合中的元素。可以理解为A = A \ B
，也就是从A
中减去B
。
举个例子，你有一个朋友列表
myFriends，和一个黑名单
blackList。
myFriends.retainAll(mutualFriends)
：会把myFriends
更新为只包含那些和mutualFriends
重叠的朋友。myFriends.removeAll(blackList)
：会把myFriends
更新为移除所有在blackList
中的朋友。
性能考量：
性能问题是使用
retainAll或
removeAll时必须考虑的，尤其是在处理大数据量时。这两个方法的性能瓶颈都出在参数集合
c的
contains()方法上。
-
参数集合
c
的类型:-
HashSet
或LinkedHashSet
: 如果c
是HashSet
或LinkedHashSet
，其contains()
方法的平均时间复杂度是O(1)
。在这种情况下，retainAll
或removeAll
的整体时间复杂度大约是O(n)
（n
是调用者集合的大小），因为它们只需要遍历一次调用者集合，并对每个元素执行一个近似常数时间的contains
查找。这通常是最高效的。 -
ArrayList
或LinkedList
: 如果c
是ArrayList
或LinkedList
，其contains()
方法的时间复杂度是O(m)
（m
是c
的大小），因为它可能需要遍历整个列表来查找元素。那么retainAll
或removeAll
的整体时间复杂度就会退化到O(n * m)
。在n
和m
都很大的情况下，这会非常慢，甚至导致程序卡死。 -
TreeSet
:TreeSet
的contains()
方法是O(log m)
。所以，如果c
是TreeSet
，那么retainAll
或removeAll
的整体时间复杂度大约是O(n * log m)
，比HashSet
慢一些，但比ArrayList
快得多。
-
-
优化策略: 当你的参数集合
c
是一个ArrayList
或其他非Set
集合，并且它包含大量元素时，一个常见的优化手段是先将其转换为HashSet
，然后再进行retainAll
或removeAll
操作。List
largeList = new ArrayList<>(...); List filterList = new ArrayList<>(...); // 假设这个列表很大 // 优化前 (潜在的 O(n*m)) // largeList.retainAll(filterList); // 优化后 (O(n) + O(m) for Set creation) Set filterSet = new HashSet<>(filterList); // O(m) largeList.retainAll(filterSet); // O(n) 这种方式，即使加上创建
HashSet
的开销，通常也比O(n*m)
的直接操作要快得多。在实际开发中，我个人经常遇到这种场景，尤其是在处理从数据库或外部接口获取的大量ID列表时，转换成HashSet
几乎是性能优化的“标准动作”。
retainAll
方法对 null
元素和自定义对象有什么特殊处理？
retainAll方法在处理
null元素和自定义对象时，确实有一些需要特别留心的地方。这不仅仅是
retainAll的问题，更是 Java 集合框架中
equals()和
hashCode()方法的通用规则。
1. null
元素处理：
Java 集合对
null元素的处理方式，取决于具体的集合实现以及
equals()方法的定义。
-
ArrayList
或HashSet
等允许null
的集合:- 如果调用者集合中包含
null
，并且参数集合c
也包含null
，那么null
会被保留下来。 - 如果调用者集合中包含
null
，但参数集合c
不包含null
，那么null
会被移除。 - 反之亦然，如果
c
中有null
，而调用者集合没有，那null
就不会被加入（因为retainAll
不会增加元素）。
- 如果调用者集合中包含
-
TreeSet
等不允许null
元素的集合:TreeSet
默认情况下不允许null
元素，因为它需要对元素进行比较排序（调用compareTo()
方法），而null
无法参与比较。- 如果你尝试将一个包含
null
的集合A
调用A.retainAll(B)
，而B
是一个TreeSet
且B
中不含null
，那么A
中的null
元素会被移除。 - 但如果
A
包含null
，并且B
也是一个TreeSet
且你通过某种方式（比如自定义Comparator
允许null
）让它能包含null
，那么retainAll
可能会正常工作。不过，这种情况比较少见，也容易出错。 - 最常见的
NullPointerException
场景是，如果参数c
中包含了null
，而调用者集合的equals
方法（或c
的contains
方法）在处理null
时没有进行适当的null
检查，就可能抛出异常。
举个例子：
ListlistWithNull = new ArrayList<>(Arrays.asList("A", null, "B")); Set setWithoutNull = new HashSet<>(Arrays.asList("A", "C")); List listWithNull2 = new ArrayList<>(Arrays.asList("A", null, "B")); Set setWithNull = new HashSet<>(Arrays.asList("A", null, "D")); listWithNull.retainAll(setWithoutNull); System.out.println("List with null after retaining set without null: " + listWithNull); // [A] (null 被移除了) listWithNull2.retainAll(setWithNull); System.out.println("List with null after retaining set with null: " + listWithNull2); // [A, null] (null 被保留了)
2. 自定义对象处理：
这是
retainAll最容易让人“踩坑”的地方之一。对于自定义对象，
retainAll完全依赖于对象自身实现的
equals()方法来判断两个对象是否“相等”。
-
未重写
equals()
和hashCode()
: 如果你创建了一个自定义类，但没有重写equals()
和hashCode()
方法，那么它将使用Object
类中默认的实现。Object
类的equals()
方法比较的是对象的内存地址（即==
运算符）。这意味着，即使两个自定义对象的所有属性都完全相同，但如果它们是不同的实例（内存地址不同），retainAll
也会认为它们是不同的对象，从而无法正确地进行交集操作。class Person { String name; int age; public Person(String name, int age) { this.name = name; this.age = age; } // 没有重写 equals() 和 hashCode() @Override public String toString() { return "Person{" + "name='" + name + '\'' + ", age=" + age + '}'; } } Listgroup1 = new ArrayList<>(); group1.add(new Person("Alice", 30)); group1.add(new Person("Bob", 25)); List group2 = new ArrayList<>(); group2.add(new Person("Alice", 30)); // 这是一个新的实例，内存地址不同 group2.add(new Person("Charlie", 35)); group1.retainAll(group2); System.out.println("自定义对象 (未重写 equals) 后的 group1: " + group1); // [] (因为没有一个对象在内存地址上是相同的)
