用JavaArrayList实现数组去重功能的三种方案

在日常的Ja va开发中，数组去重是一个再常见不过的需求了。尤其是用 ArrayList 存储数据时，重复项往往会带来不必要的麻烦。好在解决方案很成熟，关键看你是追求代码简洁、性能还是顺序保留。下面就来拆解三种主流的去重思路，从最基础的到最优雅的写法，一次性理清。

方案1：双层循环遍历去重（不依赖其他集合，纯ArrayList）

思路很直观：新建一个空的 ArrayList，遍历原集合中的每一个元素，如果新集合里还没有该元素，就添加进去——相当于人工做了一次过滤。

1. 创建一个新的 ArrayList 存放结果
2. 遍历原集合每一个元素
3. 新集合中不存在该元素才添加，自动去重

import ja va.util.ArrayList;

public class ArrayListDistinct1 {
    public static void main(String[] args) {
        // 原数组，包含重复数据
        ArrayList list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(2);
        list.add(3);
        list.add(1);
        list.add(4);
        list.add(3);

        System.out.println("去重前：" + list);
        ArrayList newList = distinctByLoop(list);
        System.out.println("去重后：" + newList);
    }

    /**
     * 双层循环去重，保留原有顺序
     */
    public static  ArrayList distinctByLoop(ArrayList oldList) {
        ArrayList result = new ArrayList<>();
        for (E item : oldList) {
            // 新集合没有当前元素才添加
            if (!result.contains(item)) {
                result.add(item);
            }
        }
        return result;
    }
}

输出：

去重前：[1, 2, 2, 3, 1, 4, 3]
去重后：[1, 2, 3, 4]

优点很明显：只依赖 ArrayList，不引入任何其他类，而且能保持元素的插入顺序。但缺点也同样突出——contains() 底层是靠遍历来检查的，数据量一大，性能就直线下降，时间复杂度 O(n²)。适合小规模数据，或者对第三方依赖有严格限制的场景。

方案2：借助 HashSet 快速去重（性能更高，推荐）

既然 Set 天生不允许重复元素，最省事的办法就是把原集合丢进 HashSet 里去重，再转回 ArrayList。一行构造器就能搞定。

import ja va.util.ArrayList;
import ja va.util.HashSet;
import ja va.util.Set;

public class ArrayListDistinct2 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add("苹果");
        list.add("香蕉");
        list.add("苹果");
        list.add("橙子");
        list.add("香蕉");

        System.out.println("去重前：" + list);
        ArrayList distinctList = distinctBySet(list);
        System.out.println("去重后：" + distinctList);
    }

    public static  ArrayList distinctBySet(ArrayList oldList) {
        // Set自动去重
        Set set = new HashSet<>(oldList);
        // 转回ArrayList
        return new ArrayList<>(set);
    }
}

注意：HashSet 会打乱原有元素顺序。如果你不关心顺序，只求去重效率，这是个好选择。

如果需要【去重+保留顺序】用 LinkedHashSet

其实很简单——把 HashSet 换成 LinkedHashSet 就行，它既能去重，又能维护元素的插入顺序。算是在效率和顺序之间找到了一个完美的平衡点。

import ja va.util.ArrayList;
import ja va.util.LinkedHashSet;
import ja va.util.Set;

public class DistinctOrder {
    public static  ArrayList distinctKeepOrder(ArrayList oldList) {
        Set set = new LinkedHashSet<>(oldList);
        return new ArrayList<>(set);
    }

    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add(5);
        list.add(3);
        list.add(5);
        list.add(1);
        ArrayList res = distinctKeepOrder(list);
        System.out.println(res); // [5, 3, 1] 顺序不变
    }
}

方案3：Ja va8 Stream一行代码去重（最简写法）

如果你用的是 JDK 8 及以上，那还有更爽的方式——Stream API 的 distinct() 方法。一行代码搞定去重，配合 toList() 转回 List，简直不能再优雅。

import ja va.util.ArrayList;
import ja va.util.List;

public class StreamDistinct {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add(2);
        list.add(2);
        list.add(7);
        list.add(7);
        list.add(9);

        // distinct() 去重，collect转回ArrayList
        List distinctList = list.stream()
                .distinct()
                .toList();

        System.out.println(distinctList);
    }
}

看起来是不是清爽很多？不过要注意，distinct() 底层也是基于 LinkedHashSet 实现的，所以它会保留第一次出现的顺序。对大部分日常开发来说，这个方案已经够用了。

总结对比