Java集合中retainAll方法使用方法-java教程-PHP中文网

retainAll方法用于求两个集合的交集，修改调用集合使其仅保留与指定集合共有的元素，基于equals方法判断元素是否相同，会改变原集合内容并返回是否发生修改。

java集合中retainall方法使用方法

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<String> myShoppingList = new ArrayList<>(Arrays.asList("Milk", "Bread", "Eggs", "Coffee", "Sugar"));
        List<String> 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<Integer> allProducts = new ArrayList<>(Arrays.asList(101, 102, 103, 104, 105, 106, 107));
        Set<Integer> 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<String> listA = new ArrayList<>(Arrays.asList("Alpha", "Beta"));
        List<String> 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
```
登录后复制
中的朋友。

性能考量：

法语写作助手

法语助手旗下的AI智能写作平台，支持语法、拼写自动纠错，一键改写、润色你的法语作文。

查看详情

性能问题是使用

retainAll

登录后复制

或

removeAll

登录后复制

时必须考虑的，尤其是在处理大数据量时。这两个方法的性能瓶颈都出在参数集合

登录后复制

的

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<String> largeList = new ArrayList<>(...);
List<String> filterList = new ArrayList<>(...); // 假设这个列表很大

// 优化前 (潜在的 O(n*m))
// largeList.retainAll(filterList);

// 优化后 (O(n) + O(m) for Set creation)
Set<String> 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()

登录后复制

方法的通用规则。

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<String> listWithNull = new ArrayList<>(Arrays.asList("A", null, "B"));
Set<String> setWithoutNull = new HashSet<>(Arrays.asList("A", "C"));
List<String> listWithNull2 = new ArrayList<>(Arrays.asList("A", null, "B"));
Set<String> 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<Person> group1 = new ArrayList<>();
group1.add(new Person("Alice", 30));
group1.add(new Person("Bob", 25));

List<Person> 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方法使用方法的详细内容，更多请关注php中文网其它相关文章！