17370845950

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

Java集合中的

retainAll

方法，说白了，就是用来求两个集合的交集。它会修改调用这个方法的集合，只保留那些同时存在于它自身和作为参数传入的另一个集合中的元素。简单来说，就是“留下共同的朋友”，把那些独有的、对方没有的元素统统移除。这在很多数据过滤和同步的场景下，简直是神来之笔。

解决方案

retainAll

方法是

java.util.Collection

接口的一部分，所以几乎所有的标准集合类，比如

ArrayList

,

HashSet

,

LinkedList

等，都支持这个操作。它的核心作用是修改当前集合，使其内容变成当前集合与指定集合的交集。

方法的签名是

boolean retainAll(Collection c)

。

• 参数

  c

  : 这是我们要用来进行交集操作的另一个集合。

  retainAll

  会检查当前集合中的每个元素，看它是否也存在于

  c

  中。
• 返回值

  boolean

  : 如果这个方法执行后，当前集合的内容发生了变化（也就是有元素被移除了），它就返回

  true

  ；如果集合没有任何变化（比如两个集合完全相同，或者当前集合是另一个集合的子集），则返回

  false

  。这个返回值其实挺有用的，可以帮助我们判断是否需要进行后续操作。

工作原理和注意事项：

retainAll

的内部实现，通常会遍历调用者集合的每个元素，然后用

c.contains(element)

来判断这个元素是否应该被保留。如果

contains

返回

false

，那么这个元素就会从调用者集合中移除。

这里有几个关键点需要注意：

1. 基于

   equals()

   方法: 元素是否“相同”完全取决于它们的

   equals()

   方法。如果你操作的是自定义对象，并且没有正确重写

   equals()

   和

   hashCode()

   方法，那么

   retainAll

   的行为可能就不是你预期的了。它可能会认为两个逻辑上相同的对象是不同的，从而导致错误的交集结果。
2. 修改原集合:

   retainAll

   是一个破坏性操作，它会直接修改调用它的集合。如果你需要保留原始集合，记得先创建一个副本。
3. 性能考量:

   c.contains(element)

   的效率是影响

   retainAll

   整体性能的关键。如果

   c

   是一个

   HashSet

   ，

   contains

   操作通常是

   O(1)

   的平均时间复杂度，所以

   retainAll

   会比较快。但如果

   c

   是一个

   ArrayList

   ，

   contains

   可能是

   O(n)

   ，那么

   retainAll

   的总时间复杂度就可能退化到

   O(n*m)

   （

   n

   是调用者集合大小，

   m

   是

   c

   的大小），这在处理大数据量时会非常慢。
4. 异常:

   • 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()

方法上。

1. 参数集合

   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

     快得多。

2. 优化策略: 当你的参数集合

   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); // [] (因为没有一个对象在内存地址上是相同的)