Java Arrays.mismatch 怎样找出两个数组的首个差异

如果两个数组只是在某个位置开始不同，最直接的定位方式是调用 Arrays.mismatch(a, b)：返回值是首个差异的下标；完全相同返回 -1；如果一个数组只是另一个数组的前缀，则返回较短数组的长度。

官方地址：https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/util/Arrays.html

这个 API 适合做协议字段校验、测试断言、缓存键对比和批量数据核对。关键是不要把返回值只理解成“找到了不同元素”：返回值还可能表示前缀结束，范围重载还会返回相对于选中范围的下标。

先用返回值判断数组处于哪种状态

可以把结果分成三类。结果为 -1 时，两个数组长度相同且所有元素顺序一致；结果大于等于 0 且小于较短数组长度时，两个数组在这个位置第一次出现不同；结果等于较短数组长度时，较短数组的全部内容都是共同前缀，差异来自长度不同。

例如 [10, 20, 30] 与 [10, 20, 99] 的返回值是 2；而 [10, 20] 与 [10, 20, 30] 的返回值也是 2，但后者不是下标为 2 的双方元素比较，而是较短数组在这里结束。

用整数组重载定位首个差异

整数组可以直接使用重载，不需要先调用 Arrays.equals 再手写循环。下面的方法把返回值转换成更适合日志和测试断言的结果。

import java.util.Arrays;

public class ArrayDiff {
    static String describe(int[] expected, int[] actual) {
        // mismatch 返回首个差异下标；-1 表示两边完全一致。
        int index = Arrays.mismatch(expected, actual);
        if (index == -1) {
            return "相同";
        }

        // 下标等于较短长度时，说明短数组只是长数组的共同前缀。
        int shorterLength = Math.min(expected.length, actual.length);
        if (index == shorterLength) {
            return "长度不同：expected=" + expected.length
                    + ", actual=" + actual.length;
        }

        // 这里仍在两边数组的有效范围内，可以安全读取差异元素。
        return "下标 " + index + " 不同：expected=" + expected[index]
                + ", actual=" + actual[index];
    }

    public static void main(String[] args) {
        System.out.println(describe(
                new int[]{10, 20, 30},
                new int[]{10, 20, 99}));
        System.out.println(describe(
                new int[]{10, 20},
                new int[]{10, 20, 30}));
        System.out.println(describe(
                new int[]{10, 20},
                new int[]{10, 20}));
    }
}

这段代码的三个结果分别对应“元素不同”“共同前缀后长度不同”和“完全相同”。实际项目中，expected 与 actual 的命名应固定下来，否则很容易把两边日志顺序写反。

按范围重载处理局部数据

只比较数组的一段时，使用带 fromIndex 和 toIndex 的重载。范围是左闭右开区间 [fromIndex, toIndex)，返回值是选中范围中的相对下标，不是原数组的绝对下标。

import java.util.Arrays;

public class RangeArrayDiff {
    static int absoluteMismatch(int[] left, int leftFrom, int leftTo,
                                int[] right, int rightFrom, int rightTo) {
        // 先得到两个范围内部的相对位置，避免误读为 left/right 的绝对下标。
        int relative = Arrays.mismatch(
                left, leftFrom, leftTo,
                right, rightFrom, rightTo);
        if (relative = Math.min(leftLength, rightLength)) {
            // 这是范围前缀结束，不存在可同时读取的差异元素。
            return -2;
        }
        return leftFrom + relative;
    }

    public static void main(String[] args) {
        int[] left = {5, 10, 20, 30, 40};
        int[] right = {0, 10, 20, 99, 40};
        // 比较 left[1..4) 与 right[1..4)，相对下标 2 映射为 left 的下标 3。
        System.out.println(absoluteMismatch(left, 1, 4, right, 1, 4));
    }
}

示例中范围内的数据分别是 [10, 20, 30] 和 [10, 20, 99]，mismatch 返回相对下标 2；加上 leftFrom=1 后，左数组的绝对下标才是 3。如果返回值等于两个范围长度中较小的那个值，应按“范围前缀结束”处理，而不是去访问越界位置。

对象数组需要 Comparator 时怎么比较

对象数组可以直接调用 Arrays.mismatch(T[] a, T[] b, Comparator super T> cmp)。比较器返回 0 的元素会被认为相等，返回非 0 的位置就是首个差异。这个重载适合按版本号、忽略大小写的字符串或业务字段比较。

import java.util.Arrays;
import java.util.Comparator;

public class ObjectArrayDiff {
    record User(String name, int level) {}

    static int firstDifferentUser(User[] left, User[] right) {
        // 只按 level 比较；name 不参与本次差异判断。
        Comparator byLevel = Comparator.comparingInt(User::level);
        return Arrays.mismatch(left, right, byLevel);
    }
}

要注意，比较器定义了“相等”的业务含义。若后续又用 Arrays.equals 做第二次校验，两个判断的规则可能不一致；应在方法名或注释中说明比较器忽略了哪些字段。

异常和边界要在调用前分层处理

官方 API 对数组引用为空时会抛出 NullPointerException；范围重载还会检查范围顺序和边界，非法范围会抛出 IllegalArgumentException 或 ArrayIndexOutOfBoundsException。这些异常不是“没有差异”的返回值，不能用 index 统一吞掉。

• 允许输入为空引用时，先在业务层决定它代表缺失、空数组还是错误。
• 比较局部数据时，明确两边范围长度是否允许不同；不同长度可能返回较短范围长度。
• 读取差异元素前，先确认返回值小于两边范围长度的最小值。
• 使用对象数组比较器时，保证比较器对本次校验的字段定义稳定。

把差异结果收敛成一个可复用入口

在测试和数据校验代码中，可以把 mismatch 作为唯一的首轮判断入口，再根据返回值决定是通过、报告元素差异，还是报告长度差异。这样既不会重复遍历数组，也不会把“前缀结束”误报成普通元素差异。

static void requireSame(int[] expected, int[] actual) {
    // 先做一次首差异定位，再按返回值生成可读的断言信息。
    int index = Arrays.mismatch(expected, actual);
    if (index == -1) {
        return;
    }
    if (index == Math.min(expected.length, actual.length)) {
        throw new AssertionError("数组长度不同");
    }
    throw new AssertionError("数组在下标 " + index + " 处不同");
}

如果需要同时展示双方的值，可以在确认不是前缀结束后读取 expected[index] 和 actual[index]。如果需要比较字节数据，选择对应的 byte[] 重载即可，返回值语义保持一致。

速查：什么时候该用哪个判断

相关问题

Arrays.mismatch 返回 -1 代表什么？

代表两个数组长度相同、元素顺序相同，比较范围内没有差异。

为什么返回值会等于数组长度？

当较短数组是较长数组的共同前缀时，返回较短数组长度，用来表示差异来自长度而不是某个双方都存在的元素。

范围重载返回的是哪个下标？

返回选中范围内的相对下标。若要映射回左数组绝对下标，需要把返回值加上左侧的 fromIndex，同时先排除范围前缀结束的情况。

Arrays.equals 和 Arrays.mismatch 怎么选？

只关心是否相等时用 Arrays.equals 更直接；需要知道首个差异位置或生成诊断信息时使用 Arrays.mismatch。