Java ArrayList retainAll() 方法（超详细）

Java ArrayList retainAll() 方法详解：如何高效保留共同元素

在 Java 的集合框架中，ArrayList 是最常用的动态数组实现之一。当我们需要从一个列表中筛选出与另一个列表共有的元素时，retainAll() 方法便显得尤为实用。它能帮助我们快速实现“保留交集”的操作，避免手写繁琐的循环判断逻辑。

今天我们就来深入剖析 Java ArrayList retainAll() 方法 的工作原理、使用场景和常见陷阱。无论你是刚接触集合操作的初学者，还是希望提升代码效率的中级开发者，这篇文章都能为你提供清晰的实践指南。

什么是 retainAll() 方法？

retainAll() 是 java.util.Collection 接口定义的一个方法，其在 ArrayList 中被具体实现。它的作用是：保留当前集合中与指定集合共有的元素，其余元素将被移除。

换句话说，这个方法执行后，原列表将只包含两个集合的“交集”部分。

💡 比喻理解：想象你有两个购物清单，一个是你想要买的东西，另一个是你朋友想要买的东西。retainAll() 就像是你把两个清单对比，只留下两人都想买的东西，然后丢掉其他内容。

方法签名

public boolean retainAll(Collection<?> c)

• 参数 c：要与当前集合进行交集运算的集合。
• 返回值：true 表示集合内容确实发生了变化（有元素被移除），false 表示没有变化。

基本使用示例

下面我们通过一个简单例子来演示 retainAll() 的基本用法。

import java.util.ArrayList;
import java.util.List;

public class RetainAllExample {
    public static void main(String[] args) {
        // 创建第一个列表：你的购物清单
        List<String> myShoppingList = new ArrayList<>();
        myShoppingList.add("牛奶");
        myShoppingList.add("面包");
        myShoppingList.add("鸡蛋");
        myShoppingList.add("苹果");

        // 创建第二个列表：朋友的购物清单
        List<String> friendShoppingList = new ArrayList<>();
        friendShoppingList.add("面包");
        friendShoppingList.add("鸡蛋");
        friendShoppingList.add("香蕉");

        System.out.println("原始我的清单：" + myShoppingList);
        System.out.println("朋友的清单：" + friendShoppingList);

        // 使用 retainAll 保留共同元素
        boolean changed = myShoppingList.retainAll(friendShoppingList);

        System.out.println("执行 retainAll 后：" + myShoppingList);
        System.out.println("是否发生变化：" + changed);
    }
}

输出结果：

原始我的清单：[牛奶, 面包, 鸡蛋, 苹果]
朋友的清单：[面包, 鸡蛋, 香蕉]
执行 retainAll 后：[面包, 鸡蛋]
是否发生变化：true

✅ 注释说明：

• myShoppingList.retainAll(friendShoppingList)：将 myShoppingList 与 friendShoppingList 做交集运算。
• 原来的 牛奶 和 苹果 不在朋友的清单中，因此被自动移除。
• changed 返回 true，表示确实有元素被移除了，集合内容发生了变化。

保留元素的底层逻辑解析

retainAll() 方法的内部实现依赖于 equals() 和 hashCode() 方法。它会遍历当前集合中的每一个元素，检查该元素是否存在于指定集合中。

如果不存在，则从当前集合中移除；如果存在，则保留。

注意事项：

• 两个元素是否“相等”，取决于它们的 equals() 方法。
• 如果你使用自定义类对象（如 Student、Product），请确保重写了 equals() 和 hashCode() 方法，否则可能导致逻辑错误。

自定义类示例

import java.util.ArrayList;
import java.util.List;

class Product {
    private String name;
    private double price;

    public Product(String name, double price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Product product = (Product) obj;
        return Double.compare(product.price, price) == 0 && name.equals(product.name);
    }

    @Override
    public int hashCode() {
        return name.hashCode() ^ Double.hashCode(price);
    }

    @Override
    public String toString() {
        return "Product{name='" + name + "', price=" + price + "}";
    }
}

public class CustomProductRetainAll {
    public static void main(String[] args) {
        List<Product> shop1 = new ArrayList<>();
        shop1.add(new Product("手机", 3999.0));
        shop1.add(new Product("耳机", 199.0));
        shop1.add(new Product("充电宝", 150.0));

        List<Product> shop2 = new ArrayList<>();
        shop2.add(new Product("耳机", 199.0));
        shop2.add(new Product("键盘", 300.0));

        System.out.println("商店1的商品：" + shop1);
        System.out.println("商店2的商品：" + shop2);

        // 保留两个商店都有的商品
        boolean changed = shop1.retainAll(shop2);

        System.out.println("交集结果：" + shop1);
        System.out.println("是否修改：" + changed);
    }
}

输出结果：

商店1的商品：[Product{name='手机', price=3999.0}, Product{name='耳机', price=199.0}, Product{name='充电宝', price=150.0}]
商店2的商品：[Product{name='耳机', price=199.0}, Product{name='键盘', price=300.0}]
交集结果：[Product{name='耳机', price=199.0}]
是否修改：true

✅ 注释说明：

• 仅当 name 和 price 都相等时，equals() 才返回 true。
• 因此 手机 和 充电宝 被移除，只有 耳机 被保留。

使用场景：实际项目中的常见应用

场景一：用户权限过滤

假设你有一个用户列表，以及一个拥有特定权限的角色列表。你想找出所有拥有该权限的用户。

List<String> allUsers = new ArrayList<>();
allUsers.add("张三");
allUsers.add("李四");
allUsers.add("王五");
allUsers.add("赵六");

List<String> adminUsers = new ArrayList<>();
adminUsers.add("李四");
adminUsers.add("赵六");
adminUsers.add("钱七");

// 只保留管理员用户
allUsers.retainAll(adminUsers);

System.out.println("管理员用户：" + allUsers);
// 输出：[李四, 赵六]

场景二：数据清洗——去除无效记录

在数据处理中，你可能需要从一个原始数据列表中，只保留那些在合法数据集中的项。

List<String> rawData = new ArrayList<>();
rawData.add("A001");
rawData.add("A002");
rawData.add("B003");
rawData.add("C004");

List<String> validCodes = new ArrayList<>();
validCodes.add("A001");
validCodes.add("B003");
validCodes.add("D005");

// 清洗无效数据
rawData.retainAll(validCodes);

System.out.println("清洗后有效数据：" + rawData);
// 输出：[A001, B003]

性能与注意事项

性能优化建议

当处理大量数据时，建议将传入的集合转换为 HashSet，以提升查找效率。

List<String> list1 = new ArrayList<>(Arrays.asList("a", "b", "c", "d"));
List<String> list2 = new ArrayList<>(Arrays.asList("b", "c", "e"));

// 优化：先转为 HashSet
Set<String> set2 = new HashSet<>(list2);
list1.retainAll(set2); // 效率更高

常见陷阱与错误用法

陷阱一：误以为 retainAll() 返回新集合

retainAll() 不会创建新集合，而是直接修改调用它的集合。

List<String> list1 = new ArrayList<>(Arrays.asList("a", "b"));
List<String> list2 = new ArrayList<>(Arrays.asList("b", "c"));

List<String> result = list1.retainAll(list2); // ❌ 错误：result 是 boolean，不是新列表

✅ 正确做法：

list1.retainAll(list2); // 直接修改 list1

陷阱二：忘记重写 equals() 和 hashCode()

如果你用自定义对象，但没有重写这两个方法，retainAll() 无法正确识别“相同”元素。

List<User> users1 = new ArrayList<>();
users1.add(new User("张三"));

List<User> users2 = new ArrayList<>();
users2.add(new User("张三"));

// 未重写 equals() 和 hashCode()
users1.retainAll(users2); // 可能不保留！

✅ 必须重写这两个方法，否则判断失败。

总结：掌握 Java ArrayList retainAll() 方法的关键点

retainAll() 方法虽然语法简单，但其背后涉及集合比较、元素去重、性能优化等多个层面的知识。掌握它不仅能让你写出更简洁的代码，还能提升程序的可读性和维护性。

• 它是实现“交集”的利器，尤其适合用于数据筛选、权限校验、去重清洗等场景。
• 使用时务必注意：原集合会被修改，且依赖 equals() 与 hashCode()。
• 大数据量下，建议将目标集合转为 HashSet 提升性能。
• 切勿误以为它返回新集合，它是“原地修改”操作。

无论你是初学者还是进阶者，只要你在处理集合交集问题，Java ArrayList retainAll() 方法 都值得你熟练掌握。

在实际开发中，善用这类内置方法，可以避免重复造轮子，让代码更优雅、更高效。希望今天的分享，能帮你真正理解并用好这个实用工具。