try (Stream<String> s = Files.lines(f)) {
    return s.filter(l -> l.startsWith("line")).toList();
}

var attrs = Files.readAttributes(p, BasicFileAttributes.class);
attrs.size() + " dir=" + attrs.isDirectory() + " created=" + attrs.creationTime();

// 아래 코드 1
try (var s = Files.list(d1)) {
    s.map(x -> x.getFileName().toString()).sorted().toList();
}

// 아래 코드 2
try (var ds = Files.newDirectoryStream(d2, "*.java")) {
    for (Path x : ds) { ... }
}

아래 결과: [d1, d1/d2, d1/d2/d3, d1/d2/d3/z.txt, d1/d2/x.java, d1/d2/y.java, d1/e.txt]

// 아래 코드 1
new String(new ByteArrayInputStream("abc".getBytes()).readAllBytes());

// 아래 코드 2
new BufferedReader(new InputStreamReader(new FileInputStream(f), UTF_8));

// 아래 코드 3
Scanner sc = new Scanner("10 20 hello");
sc.nextInt() + sc.nextInt();

try (var oos = new ObjectOutputStream(Files.newOutputStream(p))) {
    oos.writeObject(new User("Kim", 30));
}

try (var w = Files.newBufferedWriter(out)) {
    props.store(w, "saved");
}

# comment
app.name=Demo
app.port=8080
app.title=한글 제목
app.list=a,b,c

// 아래 코드 1
zos.putNextEntry(new ZipEntry("hello.txt"));
zos.write(bytes);
zos.closeEntry();

// 아래 코드 2
try (FileSystem zfs = FileSystems.newFileSystem(zip)) {
    Files.readString(zfs.getPath("hello.txt"));
}

// 아래 코드 3
new BufferedReader(new InputStreamReader(new GZIPInputStream(in), UTF_8))
        .readLine();

static void safeOverwrite(Path target, String content) throws IOException {
    Path tmp = target.resolveSibling(target.getFileName() + ".tmp");
    Files.writeString(tmp, content, StandardCharsets.UTF_8,
            StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING, StandardOpenOption.WRITE);
    Files.move(tmp, target, StandardCopyOption.REPLACE_EXISTING, StandardCopyOption.ATOMIC_MOVE);
}

Files.writeString(target, "{\"v\":1}");
safeOverwrite(target, "{\"v\":2}");
Files.readString(target);                          // 출력: {"v":2}
Files.exists(target.resolveSibling("config.json.tmp"));   // 출력: false

static long dirSize(Path dir) throws IOException {
    try (Stream<Path> s = Files.walk(dir)) {
        return s.filter(Files::isRegularFile)
                .mapToLong(p -> { try { return Files.size(p); } catch (IOException e) { return 0L; } })
                .sum();
    }
}
static Map<String, List<String>> byExtension(Path dir) throws IOException {
    try (Stream<Path> s = Files.walk(dir)) {
        return s.filter(Files::isRegularFile).collect(Collectors.groupingBy(p -> {
            String n = p.getFileName().toString();
            int i = n.lastIndexOf('.');
            return i < 0 ? "(none)" : n.substring(i + 1).toLowerCase();
        }, TreeMap::new, Collectors.mapping(p -> p.getFileName().toString(), Collectors.toList())));
    }
}

dirSize(d1);        // 출력: 20
byExtension(d1);    // 출력: {java=[x.java, y.java], txt=[z.txt, e.txt]}

static long countLinesStream(Path p) throws IOException {
    try (Stream<String> s = Files.lines(p)) { return s.count(); }
}
static long countLinesReader(Path p) throws IOException {
    try (BufferedReader r = Files.newBufferedReader(p)) {
        long n = 0;
        while (r.readLine() != null) n++;
        return n;
    }
}

countLinesStream(big);     // 출력: 100000
countLinesReader(big);     // 출력: 100000
Files.size(big);           // 출력: 1188890

try (Stream<String> s = Files.lines(big)) { s.filter(l -> l.endsWith("99999")).toList(); }
// 출력: [line 99999]
try (Stream<String> s = Files.lines(big)) { s.limit(3).toList(); }
// 출력: [line 0, line 1, line 2]

static void copyDir(Path src, Path dst) throws IOException {
    try (Stream<Path> s = Files.walk(src)) {
        for (Path p : s.toList()) {
            Path t = dst.resolve(src.relativize(p));
            if (Files.isDirectory(p)) Files.createDirectories(t);
            else Files.copy(p, t, StandardCopyOption.REPLACE_EXISTING);
        }
    }
}
static void deleteRecursively(Path root) throws IOException {
    if (!Files.exists(root)) return;
    try (Stream<Path> s = Files.walk(root)) {
        for (Path p : s.sorted(Comparator.reverseOrder()).toList()) Files.delete(p);
    }
}

copyDir(d1, d1_copy);
try (Stream<Path> s = Files.walk(d1_copy)) { s.count(); }   // 출력: 7
deleteRecursively(d1_copy);
Files.exists(d1_copy);                                       // 출력: false

static String watchDemo(Path dir) throws Exception {
    Path wd = Files.createDirectories(dir.resolve("watch"));
    try (WatchService ws = FileSystems.getDefault().newWatchService()) {
        wd.register(ws, StandardWatchEventKinds.ENTRY_CREATE,
                        StandardWatchEventKinds.ENTRY_MODIFY,
                        StandardWatchEventKinds.ENTRY_DELETE);
        Files.writeString(wd.resolve("n.txt"), "x");
        WatchKey key = ws.poll(3, TimeUnit.SECONDS);        // 무한 대기는 ws.take()
        if (key == null) return "no event";
        List<String> ev = new ArrayList<>();
        for (WatchEvent<?> e : key.pollEvents()) ev.add(e.kind().name() + ":" + e.context());
        key.reset();                                        // 다음 이벤트 받으려면 필수
        return ev.toString();
    }
}
// 출력: [ENTRY_CREATE:n.txt, ENTRY_MODIFY:n.txt]

Path out = base.resolve("out/2024/01/r.txt");
Files.createDirectories(out.getParent());
Files.writeString(out, "r");
Files.exists(out);                                   // 출력: true

String name = "orders_" + LocalDate.of(2024, 3, 5).format(DateTimeFormatter.BASIC_ISO_DATE) + ".csv";
// 출력: orders_20240305.csv

Path csv = base.resolve("d.csv");
Files.write(csv, List.of("id,name", "1,Kim", "2,Lee"));
try (Stream<String> s = Files.lines(csv)) {
    s.skip(1).map(l -> l.split(",")).map(a -> a[1]).toList();
}
// 출력: [Kim, Lee]

try (var out = new DataOutputStream(new BufferedOutputStream(Files.newOutputStream(bin)))) {
    out.writeInt(42); out.writeUTF("hi"); out.writeDouble(1.5);
}
try (var in = new DataInputStream(new BufferedInputStream(Files.newInputStream(bin)))) {
    in.readInt() + "/" + in.readUTF() + "/" + in.readDouble();
}
// 출력: 42/hi/1.5
Files.size(bin);   // 출력: 16

long n = Files.lines(p).count();          // 파일 핸들 누수 (Windows에서는 삭제/이동 실패로 이어짐)
try (Stream<String> s = Files.lines(p)) { long n = s.count(); }   // 올바름

Files.writeString(base.resolve("nodir/f.txt"), "x");   // NoSuchFileException
Files.createDirectories(p.getParent()); Files.writeString(p, "x");   // 올바름

Files.copy(src, existing);                                // FileAlreadyExistsException
Files.copy(src, existing, StandardCopyOption.REPLACE_EXISTING);   // 올바름

Path p = Path.of("data/logs/app.log");
p.endsWith(".log");        // false — 경로 요소 단위 비교
p.endsWith("app.log");     // true
p.toString().endsWith(".log");   // 문자열 검사는 이렇게

String path = dir + "/" + name;                    // OS 구분자, 중복 슬래시 문제
Path path = Path.of(dir).resolve(name);            // 올바름
Path.of("data").resolve("C:/abs/x.txt");           // C:\abs\x.txt — 절대 경로가 오면 그대로 (주의)

Files.delete(nonEmptyDir);                 // DirectoryNotEmptyException
deleteRecursively(nonEmptyDir);            // walk 역순 삭제 (스니펫 4)
Files.createDirectory(base.resolve("a/b/c"));    // a가 없으면 NoSuchFileException
Files.createDirectories(base.resolve("a/b/c"));  // 올바름

List<String> all = Files.readAllLines(huge);       // OutOfMemoryError 위험
try (var r = Files.newBufferedReader(huge)) { String line; while ((line = r.readLine()) != null) process(line); }

try (var in = new FileInputStream(f)) { int b; while ((b = in.read()) != -1) ... }   // 시스템 콜 폭증
try (var in = new BufferedInputStream(new FileInputStream(f))) { ... }               // 8KB 버퍼
// 또는 Files.newInputStream + readAllBytes / transferTo

BufferedReader r = Files.newBufferedReader(p);
Files.move(p, q);        // Windows: FileSystemException (다른 프로세스가 사용 중)
// 스트림을 먼저 close (try-with-resources 블록 밖에서 이동)