对象改了又写一遍，为什么读出来还是旧值？

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serial;
import java.io.Serializable;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.Objects;

public class ObjectStreamBoundary {
    static final class Note implements Serializable {
        @Serial private static final long serialVersionUID = 1L;
        String state;
        int revision;
        Note(String state, int revision) { this.state = state; this.revision = revision; }
        String value() { return state + ":" + revision; }
        @Override public boolean equals(Object object) {
            return object instanceof Note other
                && revision == other.revision && state.equals(other.state);
        }
        @Override public int hashCode() { return Objects.hash(state, revision); }
    }

    record Row(String name, String firstIntent, String secondIntent,
               boolean sameSourceObject, String firstRead, String secondRead,
               boolean sameReadObject, boolean equalReadValues, int encodedBytes) {
        String json() {
            return String.format(Locale.ROOT,
                "{\"case\":\"%s\",\"first_intent\":\"%s\",\"second_intent\":\"%s\","
                + "\"same_source_object\":%s,\"first_read\":\"%s\",\"second_read\":\"%s\","
                + "\"same_read_object\":%s,\"equal_read_values\":%s,\"encoded_bytes\":%d}",
                name, firstIntent, secondIntent, sameSourceObject, firstRead, secondRead,
                sameReadObject, equalReadValues, encodedBytes);
        }
        String csv() {
            return String.join(",", name, firstIntent, secondIntent,
                Boolean.toString(sameSourceObject), firstRead, secondRead,
                Boolean.toString(sameReadObject), Boolean.toString(equalReadValues),
                Integer.toString(encodedBytes));
        }
    }

    static void require(boolean condition, String message) {
        if (!condition) throw new AssertionError(message);
    }
    static Row run(String mode, Path output) throws Exception {
        Note original = new Note("draft", 1);
        Note second = original;
        String firstIntent = original.value();
        String secondIntent;
        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
        try (ObjectOutputStream stream = new ObjectOutputStream(bytes)) {
            stream.writeObject(original);
            if (!mode.equals("same_unchanged") && !mode.equals("distinct_equal")) {
                original.state = "published";
                original.revision = 2;
            }
            if (mode.equals("flush_only")) stream.flush();
            if (mode.equals("reset_before_second")) stream.reset();
            if (mode.equals("new_snapshot") || mode.equals("distinct_equal")) {
                second = new Note(original.state, original.revision);
            }
            secondIntent = second.value();
            stream.writeObject(second);
        }
        byte[] encoded = bytes.toByteArray();
        Note firstRead;
        Note secondRead;
        // Only deserialize bytes just generated above; no file, URL, or user-supplied input.
        try (ObjectInputStream stream = new ObjectInputStream(new ByteArrayInputStream(encoded))) {
            Object first = stream.readObject();
            Object next = stream.readObject();
            require(first instanceof Note && next instanceof Note, "unexpected local fixture types");
            firstRead = (Note) first;
            secondRead = (Note) next;
        }
        boolean sameReadObject = firstRead == secondRead;
        boolean expectsShared = mode.equals("same_unchanged") || mode.equals("same_mutated")
            || mode.equals("flush_only");
        String expectedSecond = mode.equals("reset_before_second") || mode.equals("new_snapshot")
            ? "published:2" : "draft:1";
        require(firstRead.value().equals("draft:1"), mode + ": first value");
        require(secondRead.value().equals(expectedSecond), mode + ": second value");
        require(sameReadObject == expectsShared, mode + ": object identity");
        if (mode.equals("distinct_equal")) {
            require(original != second && original.equals(second), "equal inputs must remain distinct");
            require(firstRead.equals(secondRead), "equal output values");
        }
        Files.write(output.resolve(mode + ".bin"), encoded);
        return new Row(mode, firstIntent, secondIntent, original == second,
            firstRead.value(), secondRead.value(), sameReadObject, firstRead.equals(secondRead), encoded.length);
    }

    public static void main(String[] args) throws Exception {
        Path output = args.length == 0 ? Path.of("object-stream-output") : Path.of(args[0]);
        Files.createDirectories(output);
        List<Row> rows = new ArrayList<>();
        for (String mode : List.of("same_unchanged", "same_mutated", "flush_only",
                "reset_before_second", "new_snapshot", "distinct_equal")) {
            rows.add(run(mode, output));
        }
        String version = System.getProperty("java.version");
        String json = "{\n  \"java_version\":\"" + version
            + "\",\n  \"input_scope\":\"only_fresh_self_generated_memory_bytes\",\n  \"rows\":[\n    "
            + String.join(",\n    ", rows.stream().map(Row::json).toList()) + "\n  ]\n}\n";
        String csv = "case,first_intent,second_intent,same_source_object,first_read,second_read,"
            + "same_read_object,equal_read_values,encoded_bytes\n"
            + String.join("\n", rows.stream().map(Row::csv).toList()) + "\n";
        Files.writeString(output.resolve("report.json"), json, StandardCharsets.UTF_8);
        Files.writeString(output.resolve("matrix.csv"), csv, StandardCharsets.UTF_8);
        System.out.println("Java " + version + "; 6 cases; only self-generated memory bytes read");
        System.out.println("same mutated / flush only: draft:1 twice, same object=true");
        System.out.println("reset / new snapshot: draft:1 then published:2, same object=false");
        System.out.println("equal distinct inputs remain distinct; PASS; " + output);
    }
}