把字节放回去以后，为什么原始流的位置没有倒退？

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.PushbackInputStream;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;

public class Main {
    private static int checks;
    @FunctionalInterface private interface CheckedAction { void run() throws Exception; }

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

    private static void rejects(Class<? extends Throwable> expected, CheckedAction action) throws Exception {
        try {
            action.run();
        } catch (Throwable error) {
            check(expected.isInstance(error), "unexpected exception: " + error);
            return;
        }
        throw new AssertionError("expected " + expected.getSimpleName());
    }

    private static byte[] ascii(String value) { return value.getBytes(StandardCharsets.US_ASCII); }
    private static String text(byte[] value) { return new String(value, StandardCharsets.US_ASCII); }

    private static int peek(PushbackInputStream input) throws IOException {
        int value = input.read();
        if (value != -1) input.unread(value); // EOF is a status, never a byte to replay.
        return value;
    }

    // This demo recognizes only ASCII letters, not a complete identifier grammar.
    private static String readLetters(PushbackInputStream input) throws IOException {
        StringBuilder token = new StringBuilder();
        int value;
        while ((value = input.read()) != -1) {
            if ((value >= 'A' && value <= 'Z') || (value >= 'a' && value <= 'z')) {
                token.append((char) value);
            } else {
                input.unread(value);
                break;
            }
        }
        return token.toString();
    }

    public static void main(String[] args) throws Exception {
        ByteArrayInputStream raw = new ByteArrayInputStream(ascii("ABC"));
        try (PushbackInputStream input = new PushbackInputStream(raw, 2)) {
            check(input.read() == 'A' && input.read() == 'B', "read original prefix");
            check(raw.available() == 1, "ByteArrayInputStream has one original byte left");
            input.unread(ascii("AB"));
            check(raw.available() == 1 && input.available() == 3, "only wrapper gains replay bytes");
            check(input.read() == 'A' && raw.available() == 1, "first replay does not move raw cursor");
            check(input.read() == 'B' && raw.available() == 1, "second replay does not move raw cursor");
            check(input.read() == 'C' && raw.available() == 0 && input.read() == -1, "then resume raw source");
            System.out.println("replay: original-remaining=1; wrapper-remaining=3; reads=ABC; raw-never-rewound");
        }

        try (PushbackInputStream input = new PushbackInputStream(new ByteArrayInputStream(new byte[0]), 2)) {
            input.unread('A');
            input.unread('B');
            String singles = text(input.readAllBytes());
            check(singles.equals("BA"), "individual pushes are last-in first-out");
            byte[] pair = ascii("AB");
            input.unread(pair);
            pair[0] = 'Z';
            String array = text(input.readAllBytes());
            check(array.equals("AB"), "array order is preserved and bytes were copied");
            System.out.println("order: unread(A),unread(B) -> " + singles + "; unread([A,B]) -> " + array);
        }

        try (PushbackInputStream input = new PushbackInputStream(new ByteArrayInputStream(new byte[0]))) {
            input.unread('A');
            rejects(IOException.class, () -> input.unread('B'));
            check(input.read() == 'A' && input.read() == -1, "overflow did not replace pending byte here");
            rejects(IOException.class, () -> input.unread(ascii("AB")));
            check(input.read() == -1, "oversized array not partly pushed here");
            input.unread('C');
            check(input.read() == 'C', "reading frees pushback capacity");
            System.out.println("default-capacity=1; extra-byte=rejected; two-byte-array=rejected; capacity-reusable=true");
        }

        try (PushbackInputStream input = new PushbackInputStream(new ByteArrayInputStream(new byte[0]))) {
            int eof = input.read();
            check(eof == -1, "empty source EOF");
            input.unread(eof); // Deliberately wrong: only the low eight bits are stored.
            int injected = input.read();
            check(injected == 255 && input.read() == -1, "unread(-1) creates FF, not EOF");
            check(peek(input) == -1 && input.read() == -1, "safe peek leaves EOF alone");
            System.out.println("EOF misuse: read=-1; unread(-1); next-read=" + injected + "; guarded-peek=-1");
        }
        try (PushbackInputStream input = new PushbackInputStream(new ByteArrayInputStream(new byte[]{(byte) 0xFF}))) {
            check(peek(input) == 255 && input.read() == 255 && input.read() == -1, "FF data differs from EOF");
        }

        try (PushbackInputStream input = new PushbackInputStream(new ByteArrayInputStream(ascii("name=42")))) {
            String token = readLetters(input);
            int delimiter = input.read();
            String tail = text(input.readAllBytes());
            check(token.equals("name") && delimiter == '=' && tail.equals("42"), "delimiter belongs to next step");
            System.out.println("letters: token=" + token + "; delimiter='" + (char) delimiter + "'; tail=" + tail);
        }
        for (String sample : new String[]{"", "name", "=42"}) {
            try (PushbackInputStream input = new PushbackInputStream(new ByteArrayInputStream(ascii(sample)))) {
                String token = readLetters(input);
                check(token.equals(sample.equals("name") ? "name" : ""), "empty or all-letter prefix");
                check(input.read() == (sample.equals("=42") ? '=' : -1), "delimiter or EOF preserved");
            }
        }

        try (PushbackInputStream input = new PushbackInputStream(new ByteArrayInputStream(new byte[0]))) {
            for (int value = 0; value < 256; value++) {
                input.unread(value);
                check(input.read() == value, "all unsigned byte values round trip");
            }
            check(!input.markSupported(), "pushback does not support mark/reset");
            input.mark(100);
            rejects(IOException.class, () -> input.reset());
        }
        byte[] original = ascii("ABCDEFGH");
        for (int count = 0; count <= original.length; count++) {
            try (PushbackInputStream input = new PushbackInputStream(new ByteArrayInputStream(original), 8)) {
                byte[] prefix = input.readNBytes(count);
                input.unread(prefix);
                check(Arrays.equals(input.readAllBytes(), original), "prefix replay for count=" + count);
            }
        }
        rejects(IllegalArgumentException.class, () -> new PushbackInputStream(new ByteArrayInputStream(new byte[0]), 0));
        PushbackInputStream closed = new PushbackInputStream(new ByteArrayInputStream(ascii("A")));
        closed.close();
        rejects(IOException.class, () -> closed.read());
        rejects(IOException.class, () -> closed.unread('A'));
        System.out.println("byte-values=256; prefix-lengths=9; mark/reset=unsupported; closed-read/unread=rejected");
        System.out.println("PASS " + checks + " checks; byte-array sources only, no file or network I/O");
    }
}