如何在Java ArrayList中高效检测并更新一维数组的重复元素？

在 Java 中使用 ArrayList 管理一维数组时，经常需要判断某个数组内容是否已经存在于集合中，如果存在就更新旧值，否则就作为新元素追加。直观做法是调用 list.contains(newArray) 或 list.indexOf(newArray)，但这两个方法的结果往往与预期不符。根本原因在于 Java 数组没有重写 equals 和 hashCode，它们比较的是堆内存中的引用地址，而不是数组内部元素是否相同。本文围绕这一差异展开，梳理几种在 ArrayList 中高效检测并更新重复一维数组的策略，包括哈希键、列表键、自定义包装类以及索引映射等方案，并分析它们在小数据量和大数据量场景下的适用性。

为什么直接使用 contains 和 indexOf 会失败

ArrayList 的 contains(Object o) 和 indexOf(Object o) 方法在内部都会调用 o.equals(element) 来判断元素是否相等。对于 int[] 或 Integer[] 这样的数组对象而言，它们没有覆盖 Object 类的 equals 方法，因此默认使用引用比较。也就是说，只有当两个引用指向同一个数组对象时，才会被认为是相等的。即使两个数组的每个元素都完全相同，只要它们是通过不同 new 创建的，contains 就会返回 false。

下面的代码可以直观展示这个问题：

ArrayList<int[]> list = new ArrayList<>();
int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
list.add(a);
System.out.println(list.contains(b)); // false
System.out.println(list.indexOf(b));  // -1

这种引用比较会让重复检测失效，后续的更新逻辑也无法定位到旧元素。更严重的是，它会让开发者在业务上产生误判：明明数据内容相同，程序却坚持认为它们是两条不同记录。要获得正确的内容等价判断，应当使用 java.util.Arrays.equals 和 java.util.Arrays.hashCode。例如 Arrays.equals(a, b) 会返回 true，因为它们逐个元素比较；Arrays.hashCode(a) 和 Arrays.hashCode(b) 的值也相同。这两个工具方法是后续构建高效检测策略的基础。

如果处理的是 Integer[] 而不是 int[]，情况也完全类似。Integer[] 的 equals 依然继承自 Object，不会逐个比较元素对象。虽然 Arrays.asList 可以把对象数组转换成 List，并借助 List.equals 实现内容比较，但对于 int[] 这种基本类型数组，Arrays.asList 会将它包装成一个只包含一个数组元素的 List，这一点在后续内容中还会进一步说明。

基于哈希键的检测与更新策略

要解决引用比较问题，最直接的思路是为每个一维数组生成一个与内容相关的键，然后使用 HashMap 保存键到 ArrayList 索引的映射。常用键有两种：字符串键和 List<Integer> 键。字符串键可以用 Arrays.toString(int[]) 生成，它会输出类似 [1, 2, 3] 的格式，既简单又直观。List<Integer> 键则需要将基本类型数组显式装箱，例如通过循环或 Arrays.stream(array).boxed().collect(Collectors.toList()) 生成。

以字符串键为例，可以先遍历已有列表构建索引，再对新数组进行查询和更新。代码如下：

HashMap<String, Integer> indexMap = new HashMap<>();
for (int i = 0; i < list.size(); i++) {
    String key = Arrays.toString(list.get(i));
    indexMap.put(key, i);
}

public void addOrUpdate(ArrayList<int[]> list,
                        HashMap<String, Integer> indexMap,
                        int[] newArray) {
    String key = Arrays.toString(newArray);
    Integer existingIndex = indexMap.get(key);
    if (existingIndex != null) {
        list.set(existingIndex, newArray);
        indexMap.put(key, existingIndex);
    } else {
        list.add(newArray);
        indexMap.put(key, list.size() - 1);
    }
}

这种方案把重复检测从线性扫描降为接近 O(1) 的哈希查找，尤其适合频繁调用更新逻辑的场景。但要特别注意，使用字符串键必须选择不容易产生歧义的生成方式。Arrays.toString 已经使用了方括号和逗号分隔，因此 [1, 23] 和 [12, 3] 不会混淆。如果为了省事自己拼接字符串，比如用空字符串或单一分隔符连接数字，就很容易出现键冲突。

此外，如果 ArrayList 中的旧数组被替换，必须同步更新 indexMap 中对应的键。虽然在上面的更新分支里旧键和新键相同，可以不改变映射关系，但如果索引中的内容发生变化，实际上也需要删除旧键并插入新键。否则当同一个索引处的数组内容被替换成另一个值时，下次查找旧内容仍会命中该索引，导致数据错乱。这个同步问题在后面的陷阱部分会进一步展开。

自定义包装类实现正确的 equals 与 hashCode

字符串键虽然实现简单，但每次检测都要生成新的字符串对象，数组长度较大或调用频繁时会带来额外的内存和 CPU 开销。更面向对象的方式是定义一个包装类，把 int[] 封装起来，并重写 equals 和 hashCode，分别委托给 Arrays.equals 和 Arrays.hashCode。这样包装类对象就可以直接作为 HashMap 或 HashSet 的键使用。

一个基础实现如下：

public class ArrayWrapper {
    private final int[] data;

    public ArrayWrapper(int[] data) {
        this.data = data.clone();
    }

    public int[] getData() {
        return data.clone();
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }
        ArrayWrapper other = (ArrayWrapper) obj;
        return Arrays.equals(this.data, other.data);
    }

    @Override
    public int hashCode() {
        return Arrays.hashCode(data);
    }
}

这个包装类采用了防御性拷贝策略。构造方法中执行 data.clone() 可以避免外部对原数组的后续修改影响包装对象的内容，getData() 同样返回副本，防止内部状态被意外改变。这样做虽然增加了一些数组复制成本，但在只需要存储键的场景下非常值得，因为键对象本来就不应该可变。

基于 ArrayWrapper 的更新逻辑可以这样写：

HashMap<ArrayWrapper, Integer> wrapperIndex = new HashMap<>();
ArrayList<ArrayWrapper> wrapperList = new ArrayList<>();

public void addOrUpdateWrapper(int[] newArray) {
    ArrayWrapper wrapper = new ArrayWrapper(newArray);
    Integer existingIndex = wrapperIndex.get(wrapper);
    if (existingIndex != null) {
        wrapperList.set(existingIndex, wrapper);
        wrapperIndex.put(wrapper, existingIndex);
    } else {
        wrapperList.add(wrapper);
        wrapperIndex.put(wrapper, wrapperList.size() - 1);
    }
}

这种实现的语义最强，也让列表本身存储的对象与索引键保持一致。虽然代码量比字符串键方案多，但它避免了每次生成字符串的成本，也提供了更好的封装性。对于需要长期维护的模块，或者后续可能扩展到多维数组、对象数组等场景，自定义包装类通常是更稳妥的选择。

完整更新流程与性能对比

从整体上看，解决 ArrayList 中一维数组重复检测问题有三种典型方案。第一种是嵌套循环，每次新数组到来时遍历整个列表，用 Arrays.equals 逐个比较，找到匹配项就更新，否则追加。这种方案时间复杂度为 O(n²)，但实现最简单，适合只有几十或几百条数据的小型集合。第二种是字符串键或 List<Integer> 键索引，首次构建索引需要 O(n) 时间，之后每次检测和更新为 O(1)。第三种是自定义包装类，复杂度与前一种相同，但在代码结构、可变性和扩展性上更优。

下面用一个简单测试对比嵌套循环和 HashMap 索引在 10000 个数组规模下的耗时差异：

ArrayList<int[]> dataList = new ArrayList<>();
for (int i = 0; i < 10000; i++) {
    dataList.add(new int[]{i, i + 1, i + 2});
}

long start = System.currentTimeMillis();
boolean found = false;
int[] target = {9999, 10000, 10001};
for (int[] item : dataList) {
    if (Arrays.equals(item, target)) {
        found = true;
        break;
    }
}
long end = System.currentTimeMillis();
System.out.println("nested loop cost: " + (end - start) + " ms, found=" + found);

这个测试只展示了嵌套循环的写法。

Java ArrayList一维数组重复元素检测修改时间：2026-08-23 11:36:19