I-O와 NIO — 스트림에서 채널까지, 자바의 입출력 총정리

Java I/O 클래스 계층

바이트 기반                    문자 기반
InputStream                   Reader
├── FileInputStream           ├── FileReader
├── ByteArrayInputStream      ├── StringReader
├── BufferedInputStream       ├── BufferedReader
└── ...                       └── InputStreamReader (바이트→문자 변환)

OutputStream                  Writer
├── FileOutputStream          ├── FileWriter
├── ByteArrayOutputStream     ├── StringWriter
├── BufferedOutputStream      ├── BufferedWriter
└── ...                       └── OutputStreamWriter (문자→바이트 변환)

try (FileInputStream fis = new FileInputStream("data.bin")) {
    int data;
    while ((data = fis.read()) != -1) { // -1이면 EOF
        System.out.print((byte) data + " ");
    }
} catch (IOException e) {
    e.printStackTrace();
}

// 파일에 바이트 단위로 쓰기
try (FileOutputStream fos = new FileOutputStream("output.bin")) {
    byte[] data = {72, 101, 108, 108, 111}; // "Hello"의 ASCII 코드
    fos.write(data);
    System.out.println("파일 쓰기 완료");
} catch (IOException e) {
    System.out.println("파일 쓰기 실패: " + e.getMessage());
}

try (FileInputStream fis = new FileInputStream("data.bin")) {
    byte[] buffer = new byte[1024]; // 1KB 버퍼
    int bytesRead;

    while ((bytesRead = fis.read(buffer)) != -1) {
        // buffer의 0부터 bytesRead까지가 실제 데이터
        System.out.println("읽은 바이트 수: " + bytesRead);
    }
} catch (IOException e) {
    e.printStackTrace();
}

// 문자 단위로 파일 읽기
try (FileReader reader = new FileReader("memo.txt")) {
    int ch;
    while ((ch = reader.read()) != -1) {
        System.out.print((char) ch); // int를 char로 변환하여 출력
    }
} catch (IOException e) {
    e.printStackTrace();
}

// 인코딩을 명시적으로 지정
try (InputStreamReader isr = new InputStreamReader(
        new FileInputStream("memo.txt"), StandardCharsets.UTF_8)) {
    int ch;
    while ((ch = isr.read()) != -1) {
        System.out.print((char) ch);
    }
} catch (IOException e) {
    e.printStackTrace();
}

// 문자 단위로 파일 쓰기
try (FileWriter writer = new FileWriter("output.txt")) {
    writer.write("안녕하세요, Java I/O입니다.\n");
    writer.write("한글도 문제없이 쓸 수 있습니다.");
} catch (IOException e) {
    e.printStackTrace();
}

버퍼 없이: 디스크 → 1문자 → 처리 → 디스크 → 1문자 → 처리 → ...
버퍼 사용: 디스크 → 8KB 한 번에 → 메모리에서 1문자씩 꺼내기 → ...

// BufferedReader는 readLine()을 제공한다 — 가장 많이 쓰는 패턴
try (BufferedReader br = new BufferedReader(new FileReader("memo.txt"))) {
    String line;
    while ((line = br.readLine()) != null) { // 한 줄씩 읽기
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}

// BufferedWriter로 효율적으로 쓰기
try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
    bw.write("첫 번째 줄");
    bw.newLine(); // 시스템에 맞는 줄바꿈 문자 삽입
    bw.write("두 번째 줄");
    bw.newLine();
    bw.write("세 번째 줄");
    // try-with-resources가 끝나면 자동으로 flush + close
} catch (IOException e) {
    e.printStackTrace();
}

// try-with-resources — AutoCloseable 구현 객체를 자동으로 닫아준다
try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}
// br.close()가 자동 호출된다

// 세미콜론으로 구분해서 여러 리소스를 선언할 수 있다
try (FileInputStream fis = new FileInputStream("input.bin");
     FileOutputStream fos = new FileOutputStream("output.bin")) {

    byte[] buffer = new byte[1024];
    int bytesRead;
    while ((bytesRead = fis.read(buffer)) != -1) {
        fos.write(buffer, 0, bytesRead); // 파일 복사
    }
} catch (IOException e) {
    e.printStackTrace();
}
// fos.close()가 먼저, 그 다음 fis.close()가 호출된다 (선언 역순)

// ByteBuffer 기본 사용법
ByteBuffer buffer = ByteBuffer.allocate(1024); // 1KB 버퍼 생성

// 쓰기 모드 — 데이터를 버퍼에 넣기
buffer.put((byte) 72);  // 'H'
buffer.put((byte) 101); // 'e'
buffer.put((byte) 108); // 'l'
buffer.put((byte) 108); // 'l'
buffer.put((byte) 111); // 'o'

// 쓰기 → 읽기 모드 전환 — 반드시 flip()을 호출해야 한다!
buffer.flip();

// 읽기 모드 — 버퍼에서 데이터 꺼내기
while (buffer.hasRemaining()) {
    System.out.print((char) buffer.get());
}
// 출력: Hello

쓰기 모드 (put 후):
[H][e][l][l][o][  ][  ]...
                ↑              ↑
            position(5)    capacity(1024)

flip() 호출 후 (읽기 모드):
[H][e][l][l][o][  ][  ]...
 ↑              ↑
position(0)  limit(5)

// FileChannel로 파일 읽기
try (FileChannel channel = FileChannel.open(
        Path.of("data.txt"), StandardOpenOption.READ)) {

    ByteBuffer buffer = ByteBuffer.allocate(1024);

    // 채널에서 버퍼로 데이터 읽기
    while (channel.read(buffer) != -1) {
        buffer.flip(); // 읽기 모드로 전환

        // 버퍼에서 데이터를 꺼내서 문자열로 변환
        byte[] bytes = new byte[buffer.remaining()];
        buffer.get(bytes);
        System.out.print(new String(bytes, StandardCharsets.UTF_8));

        buffer.clear(); // 버퍼를 비우고 다시 쓰기 모드로
    }
} catch (IOException e) {
    e.printStackTrace();
}

// FileChannel로 파일 쓰기
try (FileChannel channel = FileChannel.open(
        Path.of("output.txt"),
        StandardOpenOption.CREATE,
        StandardOpenOption.WRITE)) {

    String text = "NIO로 쓰는 파일입니다.";
    ByteBuffer buffer = ByteBuffer.wrap(text.getBytes(StandardCharsets.UTF_8));

    channel.write(buffer); // 버퍼의 내용을 채널에 쓰기
} catch (IOException e) {
    e.printStackTrace();
}

// Path 생성
Path path = Path.of("src", "main", "data.txt"); // src/main/data.txt
Path absolute = Path.of("/Users/dev/project/data.txt");

// Path 정보 조회
System.out.println(path.getFileName());    // data.txt
System.out.println(path.getParent());      // src/main
System.out.println(path.toAbsolutePath()); // 절대 경로
System.out.println(path.getNameCount());   // 3 (src, main, data.txt)

// 경로 결합
Path base = Path.of("/Users/dev");
Path full = base.resolve("project/data.txt"); // /Users/dev/project/data.txt

// 경로 정규화
Path messy = Path.of("/Users/dev/../dev/./project");
System.out.println(messy.normalize()); // /Users/dev/project

// 파일 전체를 문자열로 읽기 (Java 11+)
String content = Files.readString(Path.of("memo.txt"));
System.out.println(content);

// 파일 전체를 줄 단위 리스트로 읽기
List<String> lines = Files.readAllLines(Path.of("memo.txt"), StandardCharsets.UTF_8);
for (String line : lines) {
    System.out.println(line);
}

// 파일 전체를 바이트 배열로 읽기
byte[] bytes = Files.readAllBytes(Path.of("image.png"));

// 문자열을 파일에 쓰기 (Java 11+)
Files.writeString(Path.of("output.txt"), "Hello, NIO!");

// 줄 단위 리스트를 파일에 쓰기
List<String> lines = List.of("첫 번째 줄", "두 번째 줄", "세 번째 줄");
Files.write(Path.of("output.txt"), lines, StandardCharsets.UTF_8);

// 기존 파일에 추가하기 (APPEND 옵션)
Files.writeString(Path.of("log.txt"), "새 로그 항목\n",
        StandardOpenOption.CREATE, StandardOpenOption.APPEND);

// Files.lines()는 Stream을 반환한다 — 지연 로딩(lazy loading)
try (Stream<String> lines = Files.lines(Path.of("huge-log.txt"))) {
    long errorCount = lines
        .filter(line -> line.contains("ERROR")) // ERROR가 포함된 줄만
        .count();
    System.out.println("에러 수: " + errorCount);
}
// Stream도 AutoCloseable이므로 try-with-resources로 닫아야 한다

// 파일 존재 확인
boolean exists = Files.exists(Path.of("data.txt"));

// 파일 복사
Files.copy(Path.of("source.txt"), Path.of("backup.txt"),
        StandardCopyOption.REPLACE_EXISTING); // 이미 있으면 덮어쓰기

// 파일 이동 (이름 변경에도 사용)
Files.move(Path.of("old.txt"), Path.of("new.txt"));

// 파일 삭제
Files.delete(Path.of("temp.txt"));          // 없으면 예외 발생
Files.deleteIfExists(Path.of("temp.txt"));  // 없어도 예외 없음

// 디렉토리 생성
Files.createDirectory(Path.of("newDir"));          // 상위 디렉토리 없으면 예외
Files.createDirectories(Path.of("a/b/c/newDir"));  // 상위 디렉토리까지 한 번에

// 파일 정보
System.out.println(Files.size(Path.of("data.txt")));          // 파일 크기 (바이트)
System.out.println(Files.getLastModifiedTime(Path.of("data.txt"))); // 수정 시간
System.out.println(Files.isDirectory(Path.of("src")));         // 디렉토리인지

// 방법 1: IO 스트림
try (InputStream in = new FileInputStream(src);
     OutputStream out = new FileOutputStream(dst)) {
    byte[] buffer = new byte[8192];
    int bytesRead;
    while ((bytesRead = in.read(buffer)) != -1)
        out.write(buffer, 0, bytesRead);
}

// 방법 2: NIO FileChannel — OS 수준 최적화
try (FileChannel inCh = FileChannel.open(Path.of(src), StandardOpenOption.READ);
     FileChannel outCh = FileChannel.open(Path.of(dst),
             StandardOpenOption.CREATE, StandardOpenOption.WRITE)) {
    inCh.transferTo(0, inCh.size(), outCh);
}

// 방법 3: Files.copy() — 가장 간결
Files.copy(Path.of(src), Path.of(dst), StandardCopyOption.REPLACE_EXISTING);

// 디렉토리 내 모든 .java 파일 찾기
try (Stream<Path> paths = Files.walk(Path.of("src"))) {
    List<Path> javaFiles = paths
        .filter(Files::isRegularFile)                    // 파일만 (디렉토리 제외)
        .filter(p -> p.toString().endsWith(".java"))     // .java 확장자만
        .sorted()
        .toList();

    javaFiles.forEach(System.out::println);
    System.out.println("총 " + javaFiles.size() + "개의 Java 파일");
}

// 로그 파일에서 특정 패턴 분석
try (Stream<String> lines = Files.lines(Path.of("app.log"))) {
    // 시간대별 에러 건수 집계
    Map<String, Long> errorsByHour = lines
        .filter(line -> line.contains("ERROR"))
        .map(line -> line.substring(11, 13)) // HH 부분 추출 (시간)
        .collect(Collectors.groupingBy(
            hour -> hour,
            Collectors.counting()
        ));

    errorsByHour.entrySet().stream()
        .sorted(Map.Entry.comparingByKey())
        .forEach(e -> System.out.println(e.getKey() + "시: " + e.getValue() + "건"));
}