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
检查，就可能抛出异常。
举个例子：
List listWithNull = 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 + '}'; }}List group1 = 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); // [] (因为没有一个对象在内存地址上是相同的)
以上就是Java集合中retainAll方法使用方法的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/70489.html
微信扫一扫 
支付宝扫一扫 
