同样一个正整数，转成字节为什么会多出开头的 00？

import java.math.BigInteger;
import java.util.Arrays;
import java.util.HexFormat;

public final class Main {
    private static int checks;
    private static final HexFormat HEX = HexFormat.ofDelimiter(" ").withUpperCase();
    private static void check(boolean ok, String message) {
        checks++;
        if (!ok) throw new AssertionError(message);
    }
    private static void expect(Class<? extends Throwable> type, Runnable action) {
        try {
            action.run();
        } catch (Throwable failure) {
            check(type.isInstance(failure), "Wrong exception: " + failure);
            return;
        }
        throw new AssertionError("Expected " + type.getSimpleName());
    }
    // Application policy: unsigned, big-endian, exactly 1..32 bytes.
    private static byte[] unsignedFixed(BigInteger value, int width) {
        if (value == null || width < 1 || width > 32) {
            throw new IllegalArgumentException("value and width 1..32 are required");
        }
        if (value.signum() < 0 || value.bitLength() > width * 8) {
            throw new IllegalArgumentException("value does not fit the unsigned field");
        }
        byte[] signed = value.toByteArray();
        int skip = signed.length > 1 && signed[0] == 0 ? 1 : 0;
        int length = signed.length - skip;
        byte[] field = new byte[width];
        System.arraycopy(signed, skip, field, width - length, length);
        return field;
    }
    public static void main(String[] args) {
        int[] numbers = {-129, -128, -1, 0, 1, 127, 128, 255, 256};
        String[] encoded = {"FF 7F", "80", "FF", "00", "01", "7F", "00 80", "00 FF", "01 00"};
        for (int i = 0; i < numbers.length; i++) {
            BigInteger number = BigInteger.valueOf(numbers[i]);
            byte[] bytes = number.toByteArray();
            check(HEX.formatHex(bytes).equals(encoded[i]), "minimal signed representation");
            check(new BigInteger(bytes).equals(number), "signed round trip");
            System.out.println("signed " + number + " -> " + HEX.formatHex(bytes)
                    + " -> " + new BigInteger(bytes));
        }
        byte[] ff = {(byte) 0xFF};
        check(new BigInteger(ff).equals(BigInteger.valueOf(-1)), "byte[] constructor is signed");
        check(new BigInteger(1, ff).equals(BigInteger.valueOf(255)), "positive magnitude is unsigned");
        System.out.println("same FF: signed=" + new BigInteger(ff) + "; positive-magnitude=" + new BigInteger(1, ff));

        byte[] paddedInput = {0, 0, 0x7F};
        byte[] minimalAgain = new BigInteger(paddedInput).toByteArray();
        check(HEX.formatHex(minimalAgain).equals("7F"), "original padding is not retained");
        System.out.println("padding: " + HEX.formatHex(paddedInput) + " -> " + HEX.formatHex(minimalAgain));
        expect(NumberFormatException.class, () -> new BigInteger(new byte[0]));
        check(new BigInteger(1, new byte[0]).equals(BigInteger.ZERO), "empty magnitude represents zero");
        expect(NumberFormatException.class, () -> new BigInteger(0, new byte[]{1}));
        expect(NumberFormatException.class, () -> new BigInteger(2, new byte[0]));
        System.out.println("empty: signed=NumberFormatException; positive-magnitude=0");

        for (int value : new int[]{0, 127, 128, 255}) {
            byte[] oneByte = unsignedFixed(BigInteger.valueOf(value), 1);
            check(oneByte.length == 1 && (oneByte[0] & 0xFF) == value, "one-byte unsigned field");
            check(new BigInteger(1, oneByte).intValueExact() == value, "matching unsigned decoder");
            System.out.println("unsigned-width1 " + value + " -> " + HEX.formatHex(oneByte));
        }
        byte[] twoBytes = unsignedFixed(BigInteger.valueOf(128), 2);
        check(Arrays.equals(twoBytes, new byte[]{0, (byte) 0x80}), "width is an explicit contract");
        check(new BigInteger(unsignedFixed(BigInteger.valueOf(128), 1)).intValueExact() == -128,
                "wrong signed decoder changes the meaning");
        System.out.println("unsigned-width2 128 -> " + HEX.formatHex(twoBytes));
        expect(IllegalArgumentException.class, () -> unsignedFixed(BigInteger.valueOf(256), 1));
        expect(IllegalArgumentException.class, () -> unsignedFixed(BigInteger.valueOf(-1), 1));
        expect(IllegalArgumentException.class, () -> unsignedFixed(BigInteger.ZERO, 0));
        expect(IllegalArgumentException.class, () -> unsignedFixed(BigInteger.ZERO, 33));
        System.out.println("rejected: 256-in-width1; negative-value; width0; width33");

        int roundTrips = 0;
        for (int value = 0; value <= 65535; value++) {
            byte[] bytes = unsignedFixed(BigInteger.valueOf(value), 2);
            check(bytes.length == 2 && (bytes[0] & 0xFF) == (value >>> 8)
                    && (bytes[1] & 0xFF) == (value & 0xFF)
                    && new BigInteger(1, bytes).intValueExact() == value,
                    "two-byte oracle and round trip");
            roundTrips++;
        }
        for (int width : new int[]{4, 8, 16, 32}) {
            BigInteger max = BigInteger.ONE.shiftLeft(width * 8).subtract(BigInteger.ONE);
            byte[] bytes = unsignedFixed(max, width);
            check(bytes.length == width && new BigInteger(1, bytes).equals(max), "wide maximum round trip");
            expect(IllegalArgumentException.class, () -> unsignedFixed(max.add(BigInteger.ONE), width));
        }
        System.out.println("unsigned-width2-oracle=" + roundTrips + "; wide-boundaries=4,8,16,32");
        System.out.println("PASS " + checks);
    }
}