Path와 Files 심화

import java.nio.file.Path;

public final class UncheckedResolvedPath {
    public static void main(String[] args) {
        Path workspace = Path.of("safe-workspace").toAbsolutePath();
        String userInput = "reports/../../outside.txt";
        Path unresolved = workspace.resolve(userInput);
        System.out.println("looksInside=" + unresolved.startsWith(workspace));
        System.out.println("normalized=" + unresolved.normalize());
        System.out.println("reallyInside=" + unresolved.normalize().startsWith(workspace));
    }
}

import java.nio.file.Files;
import java.nio.file.Path;

public final class WorkspacePath {
    static Path resolveInside(Path root, String relative) {
        Path base = root.toAbsolutePath().normalize();
        Path candidate = base.resolve(relative).normalize();
        if (!candidate.startsWith(base)) throw new IllegalArgumentException("path escapes root");
        return candidate;
    }

    public static void main(String[] args) throws Exception {
        Path root = Files.createTempDirectory("workspace-");
        try {
            Path report = resolveInside(root, "reports/2026.txt");
            Files.createDirectories(report.getParent());
            Files.writeString(report, "ready");
            System.out.println(report.startsWith(root.toAbsolutePath()));
            try {
                resolveInside(root, "../outside.txt");
            } catch (IllegalArgumentException expected) {
                System.out.println("escape rejected");
            }
            Files.deleteIfExists(report);
            Files.deleteIfExists(report.getParent());
        } finally {
            Files.deleteIfExists(root);
        }
    }
}

import java.nio.charset.StandardCharsets;
import java.nio.file.FileAlreadyExistsException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.List;

public final class Utf8FilesWorkflow {
    public static void main(String[] args) throws Exception {
        Path root = Files.createTempDirectory("files-flow-");
        Path file = root.resolve("notes/today.txt");
        try {
            Files.createDirectories(file.getParent());
            try {
                Files.createFile(file);
            } catch (FileAlreadyExistsException ignored) {
                System.out.println("reusing existing file");
            }
            Files.write(file, List.of("첫 줄", "second"), StandardCharsets.UTF_8,
                    StandardOpenOption.TRUNCATE_EXISTING);
            System.out.println("size=" + Files.size(file));
            System.out.println(Files.readAllLines(file, StandardCharsets.UTF_8));
        } finally {
            Files.deleteIfExists(file);
            Files.deleteIfExists(file.getParent());
            Files.deleteIfExists(root);
        }
    }
}

import java.io.File;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.attribute.BasicFileAttributes;

public final class FileToPathBridge {
    public static void main(String[] args) throws Exception {
        Path root = Files.createTempDirectory("file-bridge-");
        Path path = root.resolve("note.txt");
        try {
            Files.writeString(path, "board", StandardCharsets.UTF_8);

            File legacyFile = path.toFile();
            Path restored = legacyFile.toPath();
            BasicFileAttributes attributes = Files.readAttributes(
                    restored, BasicFileAttributes.class, LinkOption.NOFOLLOW_LINKS);

            System.out.println("name=" + restored.getFileName());
            System.out.println("regular=" + attributes.isRegularFile());
            System.out.println("size=" + attributes.size());
        } finally {
            Files.deleteIfExists(path);
            Files.deleteIfExists(root);
        }
    }
}

name=note.txt
regular=true
size=5

import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;

public final class StreamingLineStats {
    record Stats(long lines, long nonBlank, long codePoints) {}

    static Stats analyze(Path file) throws Exception {
        try (var lines = Files.lines(file, StandardCharsets.UTF_8)) {
            long[] values = lines.map(line -> new long[] {
                    1,
                    line.isBlank() ? 0 : 1,
                    line.codePointCount(0, line.length())
            }).reduce(new long[3], (left, right) -> new long[] {
                    left[0] + right[0], left[1] + right[1], left[2] + right[2]
            });
            return new Stats(values[0], values[1], values[2]);
        }
    }

    public static void main(String[] args) throws Exception {
        Path file = Files.createTempFile("line-stats-", ".txt");
        try {
            Files.writeString(file, "alpha\n\n한글😀\n", StandardCharsets.UTF_8);
            System.out.println(analyze(file));
        } finally {
            Files.deleteIfExists(file);
        }
    }
}