如何正确比较 int 数组内容并去重：使用自定义包装类实现深度相等判断_技术教程

java 中 `hashset` 无法按数组元素内容去重，因为 `int[]` 的 `equals()` 和 `hashcode()` 默认基于引用。本文详解如何通过封装 `int[]` 为自定义类型（如 `record`），重写 `equals()` 和 `hashcode()`，确保基于数组内容的逻辑相等性判断。

在 Java 中，原始类型数组（如 int[]）是对象，但其 equals() 方法继承自 Object，仅比较内存地址；同理，hashCode() 也基于对象身份而非内容。因此，将多个内容相同但不同实例的 int[] 添加到 HashSet 中时，它们会被视为不同元素——这正是你遇到问题的根本原因：

int[] a = {1, 2, 3, 4};
int[] b = {1, 2, 3, 4};
System.out.println(a.equals(b)); // false ← 非预期！
System.out.println(Arrays.equals(a, b)); // true ← 正确的内容比较

要实现“内容去重”，必须将数组封装进一个支持值语义（value-based semantics）的类型中。推荐使用 record（Java 14+）配合 Arrays.equals() 和 Arrays.hashCode()：

✅ 正确做法：用 record 封装并重写核心方法

record Row(int[] row) {
    @Override
    public int hashCode() {
        return Arrays.hashCode(row); // 基于元素计算哈希码
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Row row1 = (Row) o;
        return Arrays.equals(row, row1.row); // 深度内容比较
    }
}

该 Row 类确保：

相同内容的 int[] 封装后 equals() 返回 true；
hashCode() 与 equals() 保持契约一致，可安全用于 HashSet、HashMap 等集合。

? 修改主逻辑（关键修复点）

替换集合类型：Set → Set
清空状态：每次调用前 registeredM.clear()，避免跨测试用例污染（Codewars 多次执行同一类）
统一包装：所有待比较的数组（包括原始矩阵和旋转变体）都必须构造为 Row 实例

完整修正版代码如下：

import java.util.*;
import java.util.stream.Collectors;

public class MatrixUniqueness {
    private static final Set registeredM = new HashSet<>();

    public static void main(String[] args) {
        int[][] ms = {
            {1, 2, 3, 4},
            {3, 1, 4, 2},
            {4, 3, 2, 1},
            {2, 4, 1, 3}
        };
        System.out.println(count_different_matrices(ms)); // 输出：1
    }

    public static int count_different_matrices(int[][] matrices) {
        registeredM.clear(); // ⚠️ 必须清空，保证函数幂等性
        Arrays.stream(matrices)
              .forEach(m -> {
                  List variants = unwrapPossibleMatrices(m);
                  if (variants.stream().noneMatch(registeredM::contains)) {
                      registeredM.add(new Row(m));
                  }
              });
        return registeredM.size();
    }

    private static List unwrapPossibleMatrices(int[] m) {
        return Arrays.asList(
            new Row(m),
            new Row(new int[]{m[2], m[0], m[3], m[1]}),
            new Row(new int[]{m[3], m[2], m[1], m[0]}),
            new Row(new int[]{m[1], m[3], m[0], m[2]})
        );
    }

    record Row(int[] row) {
        @Override
        public int hashCode() {
            return Arrays.hashCode(row);
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Row row1 = (Row) o;
            return Arrays.equals(row, row1.row);
        }
    }
}

? 注意事项与最佳实践

不要复用静态集合：registeredM 是静态字段，若未手动 clear()，多次调用 count_different_matrices() 会累积历史数据，导致错误结果（Codewars 测试即如此）。
避免 Arrays.asList(int[]) 陷阱：它返回的是 List，但 int[] 本身仍不满足值语义——必须封装。
替代方案（兼容旧版 Java）：若无法使用 record，可用普通 class + 手动实现 equals/hashCode，或改用 List（牺牲性能换简洁性）。
性能提示：Arrays.hashCode() 和 Arrays.equals() 时间复杂度为 O(n)，对小数组（如本题固定长度 4）完全可接受。

运行上述代码后，输出为 1，且控制台仅打印 [1, 2, 3, 4] —— 四个输入矩阵经旋转变换后均等价于同一规范形式，成功实现基于内容的唯一性判定。