System.arraycopy 抛异常后，目标数组为什么已经改了一部分？

import java.util.Arrays;

/** Teaching example. Single-threaded; not a transaction or benchmark. */
public final class ArraycopyFailureDemo {
    private static int checks;

    private static void check(boolean condition, String message) {
        checks++;
        if (!condition) throw new AssertionError(message);
    }

    private static void expect(Class<? extends Throwable> type, Runnable action) {
        try {
            action.run();
        } catch (Throwable failure) {
            check(type.isInstance(failure), "Expected " + type + ", got " + failure);
            return;
        }
        throw new AssertionError("Expected " + type.getSimpleName());
    }

    public static void main(String[] args) {
        Object[] mixed = {"new0", 42, "new2"};
        String[] direct = {"old0", "old1", "old2"};
        expect(ArrayStoreException.class,
                () -> System.arraycopy(mixed, 0, direct, 0, mixed.length));
        check(Arrays.equals(direct, new String[]{"new0", "old1", "old2"}),
                "The assignable prefix must already have been copied");
        System.out.println("direct.type-failure=" + Arrays.toString(direct));

        Object[] offsetSource = {99, "prefix", 42, "tail"};
        String[] offsetTarget = {"left", "old1", "old2", "right"};
        expect(ArrayStoreException.class,
                () -> System.arraycopy(offsetSource, 1, offsetTarget, 1, 3));
        check(Arrays.equals(offsetTarget, new String[]{"left", "prefix", "old2", "right"}),
                "Only the successful prefix inside the requested destination range changes");
        System.out.println("offset.type-failure=" + Arrays.toString(offsetTarget));

        String[] firstFailure = {"old0", "old1"};
        expect(ArrayStoreException.class,
                () -> System.arraycopy(new Object[]{42, "ok"}, 0, firstFailure, 0, 2));
        check(Arrays.equals(firstFailure, new String[]{"old0", "old1"}),
                "An incompatible first element leaves a zero-length copied prefix");
        System.out.println("first-element.type-failure=" + Arrays.toString(firstFailure));

        int[] outOfBounds = {7, 8};
        expect(IndexOutOfBoundsException.class,
                () -> System.arraycopy(new int[]{1, 2}, 0, outOfBounds, 0, 3));
        check(Arrays.equals(outOfBounds, new int[]{7, 8}),
                "A range failure must not modify the destination");
        System.out.println("range-failure=" + Arrays.toString(outOfBounds));

        long[] primitiveMismatch = {7L, 8L};
        expect(ArrayStoreException.class,
                () -> System.arraycopy(new int[]{1, 2}, 0, primitiveMismatch, 0, 2));
        check(Arrays.equals(primitiveMismatch, new long[]{7L, 8L}),
                "Primitive arrays do not apply numeric widening during arraycopy");
        System.out.println("primitive-type-failure=" + Arrays.toString(primitiveMismatch));

        String[] stagedTarget = {"old0", "old1", "old2"};
        expect(ArrayStoreException.class, () -> {
            String[] staged = Arrays.copyOf(mixed, mixed.length, String[].class);
            // This statement is not reached when staging rejects an element.
            System.arraycopy(staged, 0, stagedTarget, 0, staged.length);
        });
        check(Arrays.equals(stagedTarget, new String[]{"old0", "old1", "old2"}),
                "Failed staging leaves the separate destination untouched");
        System.out.println("staged.type-failure=" + Arrays.toString(stagedTarget));

        Object[] compatible = {"new0", "new1", "new2"};
        String[] staged = Arrays.copyOf(compatible, compatible.length, String[].class);
        check(staged.getClass() == String[].class, "Staging uses the requested runtime array type");
        System.arraycopy(staged, 0, stagedTarget, 0, staged.length);
        check(Arrays.equals(stagedTarget, new String[]{"new0", "new1", "new2"}),
                "Successful staging permits the known-valid destination copy");
        System.out.println("staged.success=" + Arrays.toString(stagedTarget));
        System.out.println("PASS " + checks);
    }
}

import java.util.Arrays;

/** Independent boundary checks for requested ranges and null values. */
public final class ArraycopyBoundaryProbe {
    private static int checks;
    private static void check(boolean condition, String reason) {
        checks++;
        if (!condition) throw new AssertionError(reason);
    }
    private static void expect(Class<? extends Throwable> type, Runnable action) {
        try {
            action.run();
        } catch (Throwable failure) {
            check(type.isInstance(failure), "Expected " + type + ", got " + failure);
            return;
        }
        throw new AssertionError("Expected " + type.getSimpleName());
    }
    public static void main(String[] args) {
        Object[] mixed = {"prefix", 42};
        String[] emptyTarget = {"old0", "old1"};
        // End indexes are legal when the length is zero.
        System.arraycopy(mixed, mixed.length, emptyTarget, emptyTarget.length, 0);
        check(Arrays.equals(emptyTarget, new String[]{"old0", "old1"}),
                "A valid empty range changes nothing");
        System.out.println("valid-empty-range=" + Arrays.toString(emptyTarget));

        String[] nullableTarget = {"old0", "old1"};
        System.arraycopy(new Object[]{null, "ok"}, 0, nullableTarget, 0, 2);
        check(Arrays.equals(nullableTarget, new String[]{null, "ok"}),
                "A null element is assignable to a reference component type");
        System.out.println("null-element=" + Arrays.toString(nullableTarget));

        String[] excludedTarget = {"old0", "old1"};
        System.arraycopy(mixed, 0, excludedTarget, 0, 1);
        check(Arrays.equals(excludedTarget, new String[]{"prefix", "old1"}),
                "The incompatible element at srcPos + length is excluded");
        System.out.println("incompatible-at-exclusive-end=" + Arrays.toString(excludedTarget));

        String[] includedTarget = {"old0", "old1"};
        expect(ArrayStoreException.class,
                () -> System.arraycopy(mixed, 0, includedTarget, 0, 2));
        check(Arrays.equals(includedTarget, new String[]{"prefix", "old1"}),
                "Extending the range includes the failing element after the copied prefix");
        System.out.println("same-source-longer-range=ArrayStoreException; "
                + Arrays.toString(includedTarget));

        String[] skippedHeadTarget = {"old0", "old1"};
        System.arraycopy(new Object[]{42, "tail"}, 1, skippedHeadTarget, 0, 1);
        check(Arrays.equals(skippedHeadTarget, new String[]{"tail", "old1"}),
                "An incompatible element before srcPos is also outside the request");
        System.out.println("incompatible-before-start=" + Arrays.toString(skippedHeadTarget));

        expect(NullPointerException.class,
                () -> System.arraycopy(null, 0, emptyTarget, 0, 0));
        check(Arrays.equals(emptyTarget, new String[]{"old0", "old1"}),
                "A null source array is invalid even for zero length");
        System.out.println("null-array-empty-range=NullPointerException");
        System.out.println("PASS " + checks);
    }
}