Java集合retainAll方法使用教程

本篇文章给大家分享《Java集合retainAll方法详解》，覆盖了文章的常见基础知识，其实一个语言的全部知识点一篇文章是不可能说完的，但希望通过这些问题，让读者对自己的掌握程度有一定的认识(B 数)，从而弥补自己的不足，更好的掌握它。

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<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 中的朋友。

性能考量：

性能问题是使用 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<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() 方法的通用规则。

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<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方法使用教程》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！