UTF-8 已读对，properties 里的 Windows 路径为什么还是变了？

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StringReader;
import java.nio.charset.StandardCharsets;
import java.util.Objects;
import java.util.Properties;

/** Teaching example. All fixtures are in memory and output is ASCII. */
public final class PropertiesLayersDemo {
    private static int checks;

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

    private static Properties viaBytes(byte[] bytes) throws IOException {
        Properties p = new Properties();
        try (ByteArrayInputStream in = new ByteArrayInputStream(bytes)) {
            p.load(in);
        }
        return p;
    }

    private static Properties viaUtf8Reader(byte[] bytes) throws IOException {
        Properties p = new Properties();
        try (InputStreamReader reader = new InputStreamReader(
                new ByteArrayInputStream(bytes), StandardCharsets.UTF_8)) {
            p.load(reader);
        }
        return p;
    }

    private static Properties viaCharacters(String text) throws IOException {
        Properties p = new Properties();
        try (StringReader reader = new StringReader(text)) {
            p.load(reader);
        }
        return p;
    }

    private static String visible(String value) {
        StringBuilder out = new StringBuilder();
        for (int i = 0; i < value.length(); i++) {
            char c = value.charAt(i);
            if (c == '\\') out.append("\\\\");
            else if (c == '\t') out.append("<TAB>");
            else if (c < 32 || c > 126) out.append(String.format("U+%04X", (int) c));
            else out.append(c);
        }
        return out.toString();
    }

    public static void main(String[] args) throws IOException {
        String chinese = "\u4e2d\u6587";
        String slash = Character.toString((char) 92);
        String wantedPath = "C:" + slash + "temp" + slash + "logs";
        // Concatenating a backslash character separates Java literal syntax
        // from the actual properties text passed to load().
        String rawText = "name=" + chinese + "\npath=" + wantedPath + "\n";
        byte[] utf8 = rawText.getBytes(StandardCharsets.UTF_8);
        Properties byteLoaded = viaBytes(utf8);
        Properties readerLoaded = viaUtf8Reader(utf8);

        check(!Objects.equals(chinese, byteLoaded.getProperty("name")),
                "load(InputStream) does not decode UTF-8 Chinese");
        check(Objects.equals(new String(chinese.getBytes(StandardCharsets.UTF_8),
                        StandardCharsets.ISO_8859_1), byteLoaded.getProperty("name")),
                "The wrong result is exactly UTF-8 bytes interpreted as Latin-1");
        check(Objects.equals(chinese, readerLoaded.getProperty("name")),
                "Explicit UTF-8 decoding restores Chinese");

        String parsedRawPath = "C:" + '\t' + "emplogs";
        check(Objects.equals(parsedRawPath, byteLoaded.getProperty("path")),
                "Properties grammar consumes the raw path backslashes");
        check(Objects.equals(parsedRawPath, readerLoaded.getProperty("path")),
                "Choosing UTF-8 does not disable properties escapes");
        check(!Objects.equals(wantedPath, readerLoaded.getProperty("path")),
                "Correct decoding alone is insufficient for the path");

        String escapedText = "name=" + chinese + "\npath="
                + wantedPath.replace(slash, slash + slash) + "\n";
        Properties escaped = viaUtf8Reader(escapedText.getBytes(StandardCharsets.UTF_8));
        check(Objects.equals(chinese, escaped.getProperty("name")), "Escaped fixture retains Chinese");
        check(Objects.equals(wantedPath, escaped.getProperty("path")),
                "Two backslashes in properties text produce one literal backslash");

        String asciiText = "name=" + slash + "u4e2d" + slash + "u6587\n";
        check(Objects.equals(chinese, viaBytes(asciiText.getBytes(StandardCharsets.US_ASCII))
                .getProperty("name")), "ASCII Unicode escapes work with byte overload");
        check(Objects.equals(chinese, viaUtf8Reader(asciiText.getBytes(StandardCharsets.US_ASCII))
                .getProperty("name")), "ASCII Unicode escapes work with Reader overload");
        check(Objects.equals("qb", viaCharacters("value=" + slash + "q" + slash + "b\n")
                .getProperty("value")), "Unknown escape and backslash-b drop the backslash");

        boolean rejected = false;
        try {
            viaCharacters("value=" + slash + "u12G4\n");
        } catch (IllegalArgumentException expected) {
            rejected = true;
        }
        check(rejected, "Malformed Unicode escape is rejected, unlike unknown ordinary escapes");

        System.out.println("input.raw-path=" + visible(wantedPath));
        System.out.println("bytes.name=" + visible(byteLoaded.getProperty("name")));
        System.out.println("utf8-reader.name=" + visible(readerLoaded.getProperty("name")));
        System.out.println("bytes.raw-path=" + visible(byteLoaded.getProperty("path")));
        System.out.println("utf8-reader.raw-path=" + visible(readerLoaded.getProperty("path")));
        System.out.println("utf8-reader.escaped-path=" + visible(escaped.getProperty("path")));
        System.out.println("ascii-unicode.name=" + visible(viaBytes(
                asciiText.getBytes(StandardCharsets.US_ASCII)).getProperty("name")));
        System.out.println("malformed-unicode.rejected=" + rejected);
        System.out.println("PASS " + checks);
    }
}

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Map;
import java.util.Objects;
import java.util.Properties;
import java.util.TreeMap;

/** Independent boundary checks; creates only an optional explicitly named output file. */
public final class PropertiesRoundTripProbe {
    private static int checks;
    private static void check(boolean condition, String reason) {
        checks++;
        if (!condition) throw new AssertionError(reason);
    }
    private static String visible(String value) {
        StringBuilder out = new StringBuilder();
        for (int i = 0; i < value.length(); i++) {
            char c = value.charAt(i);
            if (c == '\\') out.append("\\\\");
            else if (c == ' ') out.append("<SP>");
            else if (c < 32 || c > 126) out.append(String.format("U+%04X", (int) c));
            else out.append(c);
        }
        return out.toString();
    }
    public static void main(String[] args) throws Exception {
        String slash = Character.toString((char) 92);
        Map<String, String> expected = new TreeMap<>();
        expected.put("path", "C:" + slash + "temp" + slash + "logs");
        expected.put(" \u914d\u7f6e" + slash + "\u8def\u5f84:key #= ",
                "  C:" + slash + "\u4e2d\u6587\u76ee\u5f55" + slash + "file name:#=!.txt  ");
        expected.put("#leading:key", "#literal: value " + slash);
        expected.put("\u4e2d\u6587\u952e", "\u4e2d\u6587\u503c # : = " + slash);
        Properties original = new Properties();
        expected.forEach(original::setProperty);

        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
        try (OutputStreamWriter writer = new OutputStreamWriter(bytes, StandardCharsets.UTF_8)) {
            // The API escapes the properties grammar; the Writer controls encoding.
            original.store(writer, null);
        }
        byte[] encoded = bytes.toByteArray();
        Properties reloaded = new Properties();
        try (InputStreamReader reader = new InputStreamReader(
                new ByteArrayInputStream(encoded), StandardCharsets.UTF_8)) {
            reloaded.load(reader);
        }
        check(reloaded.stringPropertyNames().equals(expected.keySet()),
                "All original keys, including spaces and syntax characters, must survive");
        for (Map.Entry<String, String> entry : expected.entrySet()) {
            check(Objects.equals(entry.getValue(), reloaded.getProperty(entry.getKey())),
                    "Value changed for " + visible(entry.getKey()));
            System.out.println("roundtrip[" + visible(entry.getKey()) + "]="
                    + visible(reloaded.getProperty(entry.getKey())));
        }

        // store(Writer) inserts a date comment. Keep the complete bytes for saving;
        // omit comments and sort data lines only for stable diagnostic output.
        String serialized = new String(encoded, StandardCharsets.UTF_8);
        serialized.lines().filter(line -> !line.startsWith("#") && !line.startsWith("!"))
                .sorted().forEach(line -> System.out.println("stored-data=" + visible(line)));
        if (args.length == 1) Files.write(Path.of(args[0]), encoded);
        System.out.println("full-stored-bytes-are-not-a-deterministic-format");
        System.out.println("PASS " + checks);
    }
}