Unit 7.5 — 오버헤드와 File 객체
F-LAB JAVA · 3주차 · Phase 7 · I/O 시스템 큰 그림
🏆 Phase 7 완주 — I/O 시스템 마스터
📌 학습 목표
이 Unit을 끝내면 다음을 답할 수 있어야 한다.
- 오버헤드 (Overhead) 의 정의와 종류는?
- I/O 의 오버헤드 가 발생하는 4가지 지점은?
- File 객체 의 정의와 주요 메서드는?
- createNewFile, getAbsolutePath, getCanonicalPath, getName, getParent 의 정확한 차이는?
- "디렉토리는 자동 생성되지 않는다" 가 어떤 버그를 만드나?
- mkdir vs mkdirs 의 차이는?
- File 의 한계 가 NIO.2 의 Path/Files 에서 어떻게 해결되나?
- File → Path 마이그레이션 전략은?
- Phase 7 의 모든 학습 종합은?
🎯 핵심 한 문장
오버헤드 (Overhead) 는 "본 작업 외에 추가로 드는 간접 비용" 이며, I/O 는 시스템 호출, 버퍼링, 직렬화, 보조 스트림 중첩 등 곳곳에서 오버헤드가 발생한다.
File 객체 는 Java 1.0 의 파일 추상화로createNewFile,getAbsolutePath,getCanonicalPath,getName,getParent등 메서드를 제공하지만,
boolean 반환의 진단 불가, 디렉토리 자동 생성 안 함, 심볼릭 링크 처리 X, 풍부한 속성 X 등 한계로 NIO.2 의Path+Files가 권장된다.
특히file.createNewFile()이 실패하는 가장 흔한 이유는 부모 디렉토리가 없어서 —mkdirs()를 먼저 호출해야.
Phase 7 완주: I/O 의 정의 → IO/NIO/NIO.2 진화 → Stream/Channel 정밀 → 동시성 모델 → 실무 함정 의 5단계로 자바 I/O 의 큰 그림 완성.
비유 — 음식 배달의 오버헤드
본 작업: 음식 만들기 (5분)
오버헤드:
- 주문 받기 (2분)
- 포장 (1분)
- 배달원 호출 (1분)
- 배달 (15분)
- 결제 처리 (1분)
총: 25분
본 작업: 5분 (20%)
오버헤드: 20분 (80%)
I/O 의 오버헤드:
본 작업: 데이터 읽기 (수 마이크로초)
오버헤드:
- 시스템 호출 (수 마이크로초)
- 컨텍스트 스위칭
- 버퍼 복사
- 보조 스트림 중첩
→ I/O 자체가 오버헤드의 결정체→ 오버헤드 = 본 작업 외의 모든 간접 비용.
🧭 9개 섹션 로드맵
1. 오버헤드의 정의와 종류
2. I/O 의 오버헤드가 발생하는 지점
3. File 객체의 정의와 구조
4. File 의 주요 메서드 정밀
5. "디렉토리는 자동 생성 안 됨" 함정
6. mkdir vs mkdirs, 그 외 함정들
7. File 의 한계 종합 + NIO.2 해결
8. Phase 7 완주 정리 + Phase 8 예고
9. 면접 + 자기 점검1️⃣ 오버헤드의 정의와 종류
1.1 오버헤드의 정의
오버헤드 (Overhead):
본 작업을 수행하는 데 필요하지만,
본 작업 자체가 아닌 추가 비용.
종류:
- 시간 (CPU 사이클)
- 메모리 (버퍼, 객체)
- 자원 (스레드, 소켓, 파일 핸들)
- 네트워크 (대역폭)
예:
- 10초 작업이 20초 걸림 → 오버헤드 10초
- 1KB 데이터 처리에 10KB 메모리 → 9KB 오버헤드1.2 오버헤드의 종류
시간 오버헤드:
- 작업 시작 전 준비 (객체 생성, 초기화)
- 작업 중 추가 처리 (변환, 검증)
- 작업 종료 후 정리 (close, GC)
메모리 오버헤드:
- 버퍼 크기
- 객체 헤더
- 캐시
- 임시 데이터
자원 오버헤드:
- 스레드 (메모리 + 컨텍스트 스위칭)
- 파일 핸들
- 소켓 연결
- DB 연결
네트워크 오버헤드:
- HTTP 헤더
- TCP 헤더
- TLS 핸드셰이크
- 재전송1.3 좋은 vs 나쁜 오버헤드
좋은 오버헤드 (피할 수 없음):
- try-with-resources 의 자원 정리
- 트랜잭션 관리
- 보안 검증
- 로깅 (적절히)
나쁜 오버헤드 (피할 수 있음):
- 불필요한 객체 생성
- 과도한 직렬화
- 매번 새 Connection
- 비효율적 알고리즘1.4 오버헤드 측정
// 시간 오버헤드 측정
long start = System.nanoTime();
operation();
long elapsed = System.nanoTime() - start;
System.out.println("Took " + elapsed + " ns");
// 메모리 오버헤드 측정
Runtime runtime = Runtime.getRuntime();
long beforeMem = runtime.totalMemory() - runtime.freeMemory();
operation();
long afterMem = runtime.totalMemory() - runtime.freeMemory();
System.out.println("Used " + (afterMem - beforeMem) + " bytes");
// 프로파일링 도구
// - JProfiler, YourKit
// - JFR (Java Flight Recorder)
// - async-profiler1.5 오버헤드의 합리성
오버헤드는 항상 나쁜가? — 아니다.
좋은 trade-off:
- 버퍼링: 메모리 ↑, 속도 ↑↑ → 좋음
- 캐시: 메모리 ↑, 시간 ↓↓ → 좋음
- try-with-resources: 코드 ↑, 안전성 ↑↑ → 좋음
나쁜 trade-off:
- 과도한 추상화: 복잡도 ↑, 효과 미미
- 매번 새 Connection: 자원 ↑, 무의미
판단 기준:
- 본 작업 대비 합리적 비율?
- 가치를 더하는가?1.6 ILIC 의 오버헤드 분석
// 예: ShipmentService.findById
@Transactional
public Shipment findById(Long id) {
// 1. 트랜잭션 시작 — 오버헤드 (~1ms)
// 2. JPA 의 EntityManager — 오버헤드 (~0.5ms)
Shipment s = repository.findById(id).orElseThrow();
// 3. SQL 실행 + 결과 매핑 — 본 작업 (~10ms)
return s;
// 4. 트랜잭션 종료 — 오버헤드 (~0.5ms)
}
// 분석:
// 본 작업: 10ms (DB 쿼리)
// 오버헤드: 2ms (트랜잭션, JPA)
// 비율: 오버헤드 20%
// 합리적1.7 자기 점검 답변
오버헤드의 정의와 종류는?
답:
1. 정의:
- 본 작업 외의 추가 비용
- 시간, 메모리, 자원, 네트워크
-
종류:
- 시간: 시스템 호출, 컨텍스트 스위칭
- 메모리: 버퍼, 객체 헤더
- 자원: 스레드, Connection
- 네트워크: 헤더, 핸드셰이크
-
합리성:
- 좋은 오버헤드: 안전성, 성능
- 나쁜 오버헤드: 불필요한 복잡도
-
측정:
- System.nanoTime
- 프로파일링 도구
- JFR
2️⃣ I/O 의 오버헤드가 발생하는 지점
2.1 I/O 오버헤드의 4가지 지점
I/O 오버헤드 발생 지점:
1. 시스템 호출 (System Call)
- JVM ↔ OS 전환 비용
- 매 read/write 마다
2. 컨텍스트 스위칭
- user space ↔ kernel space
- 한 번에 ~1μs
3. 버퍼 복사
- kernel buffer → user buffer
- 또는 그 반대
4. 추상화 비용
- Decorator 중첩
- 객체 생성
- 가상 메서드 호출2.2 시스템 호출의 오버헤드
// 1바이트씩 읽기 — 매번 시스템 호출
FileInputStream fis = new FileInputStream("file.txt");
int b;
while ((b = fis.read()) != -1) {
// 매 read() 가 read() 시스템 호출
// 1MB 파일 = 1,048,576번 호출
// 각 호출 ~1μs → 총 ~1초
}
// 8KB 단위 — 시스템 호출 ↓
byte[] buf = new byte[8192];
int n;
while ((n = fis.read(buf)) != -1) {
// 1MB / 8KB = 128번 호출
// ~0.128ms
// 시스템 호출 오버헤드 ~7,800배 절감
}2.3 버퍼 복사의 오버헤드
일반 read 의 데이터 흐름:
디스크 → kernel buffer (DMA)
↓
user buffer (CPU 복사)
↓
JVM heap (Heap Buffer 인 경우 한 번 더)
매 복사가 메모리 대역폭 소모.
해결:
- Direct Buffer: kernel ↔ direct buffer 만
- zero-copy: kernel 내에서 직접 (transferTo)
- Memory-mapped: 페이지 캐시 활용2.4 추상화 비용
// Decorator 중첩의 비용
ObjectInputStream ois = new ObjectInputStream(
new BufferedInputStream(
new FileInputStream("data.dat")));
// 매 read():
// 1. ObjectInputStream.read()
// 2. → BufferedInputStream.read()
// 3. → FileInputStream.read()
// 4. → native read system call
// 5. → kernel
// 6. → 데이터 반환 (역순)
// 매 호출마다 4-5번의 메서드 호출
// JIT 가 인라이닝하지만 약간의 오버헤드2.5 자원 관리의 오버헤드
// Connection 매번 생성 (안 좋음)
public void process() {
Connection conn = DriverManager.getConnection(url); // 매번 연결
// ~100ms 비용
// ...
conn.close();
}
// Connection Pool 활용 (좋음)
public void process() {
try (Connection conn = dataSource.getConnection()) { // 풀에서 가져옴
// ~0.1ms 비용
// ...
}
}
// 오버헤드 절감: ~1000배2.6 직렬화의 오버헤드
// 직렬화는 비싼 작업
class Shipment implements Serializable {
private Long id;
private String blNo;
// ...
}
// 오버헤드:
// 1. Reflection 기반 필드 접근 (느림)
// 2. 클래스 메타데이터 저장
// 3. transient 필드 처리
// 4. ObjectStream 자체의 오버헤드
// 측정:
// 작은 객체: ~10μs per 직렬화
// 큰 객체: ~ms
// 대안:
// - JSON (Jackson)
// - Protobuf, Avro
// - 더 효율적2.7 네트워크의 오버헤드
HTTP 요청의 오버헤드:
1. DNS lookup: ~10ms
2. TCP 핸드셰이크: 1-RTT
3. TLS 핸드셰이크: 2-RTT
4. HTTP 헤더: ~500바이트
5. 응답 헤더: ~500바이트
작은 응답 (1KB):
- 총 시간: ~100ms
- 본 데이터: 1KB
- 오버헤드 헤더: 1KB (100%)
큰 응답 (1MB):
- 본 데이터: 1MB
- 오버헤드: 1KB (~0.1%)
→ 큰 요청 1번 > 작은 요청 1000번2.8 ILIC 의 I/O 오버헤드 최적화
public class ShipmentExportService {
// ❌ 나쁜 패턴 — 매번 새 Connection
public void exportAllBad() throws Exception {
for (Shipment s : repository.findAll()) {
Connection conn = DriverManager.getConnection(url);
// 매번 ~100ms
// ...
conn.close();
}
}
// ✓ 좋은 패턴 — Connection Pool + Buffered + Stream
public void exportAllGood(Path dest) throws IOException {
try (Connection conn = dataSource.getConnection();
PreparedStatement ps = conn.prepareStatement("SELECT * FROM shipments");
ResultSet rs = ps.executeQuery();
BufferedWriter writer = Files.newBufferedWriter(dest)) {
writer.write("id,blNo,weight\n");
while (rs.next()) {
writer.write(rs.getLong("id") + ",");
writer.write(rs.getString("bl_no") + ",");
writer.write(rs.getBigDecimal("weight") + "\n");
}
}
// 한 Connection, 한 Statement, 한 ResultSet
// BufferedWriter 로 디스크 I/O ↓
}
// ✓✓ 더 좋은 패턴 — Streaming + Bulk Insert
@Transactional
public void importBulk(List<Shipment> shipments) {
// 1000개씩 묶어서
for (List<Shipment> chunk : Lists.partition(shipments, 1000)) {
repository.saveAll(chunk);
}
// saveAll 이 내부적으로 batch insert
}
}2.9 자기 점검 답변
I/O 오버헤드가 발생하는 4가지 지점은?
답:
1. 시스템 호출:
- JVM ↔ OS 전환
- 매 read/write
- Buffered 로 절감
-
컨텍스트 스위칭:
- user ↔ kernel space
- ~1μs
-
버퍼 복사:
- kernel ↔ user
- Direct Buffer 또는 zero-copy 로 절감
-
추상화 비용:
- Decorator 중첩
- Reflection (직렬화)
- JIT 가 일부 절감
최적화:
- Buffered + byte[]
- Direct Buffer
- zero-copy (transferTo)
- Connection Pool
- Bulk Insert/Stream
3️⃣ File 객체의 정의와 구조
3.1 File 의 정의
java.io.File:
파일과 디렉토리의 추상적 경로 표현.
Java 1.0 부터 존재.
특징:
- 인스턴스 객체
- 경로 + 약간의 메타데이터
- 파일이 실제로 존재하지 않아도 객체 생성 가능3.2 File 의 생성자
// 5가지 생성자
// 1. 경로 문자열
File f1 = new File("file.txt");
File f2 = new File("/home/user/file.txt");
File f3 = new File("C:\\Users\\user\\file.txt");
// 2. 부모 + 자식 (이름)
File f4 = new File("/home/user", "file.txt");
// → /home/user/file.txt
// 3. 부모 File + 자식 (이름)
File parent = new File("/home/user");
File f5 = new File(parent, "file.txt");
// 4. URI
URI uri = URI.create("file:///home/user/file.txt");
File f6 = new File(uri);
// 5. (private 또는 deprecated 생성자 있음)3.3 File 객체의 본질
// File 은 경로의 추상화 — 실제 파일과 별개
File f = new File("nonexistent.txt");
// 객체 생성 성공
// 실제 파일은 없음
f.exists(); // false
f.length(); // 0
f.canRead(); // false
f.getAbsolutePath(); // 작동 (경로만)
// 즉:
// File 객체 = 경로 정보
// 실제 파일 = OS 의 파일 시스템 자원
// 두 개념 분리3.4 File 의 주요 메서드 그룹
정보 조회:
- exists(), length(), lastModified()
- canRead(), canWrite(), canExecute()
- isFile(), isDirectory(), isHidden()
경로 조회:
- getName(), getPath(), getParent()
- getAbsolutePath(), getCanonicalPath()
- toURI(), toPath()
생성/삭제:
- createNewFile(), delete()
- mkdir(), mkdirs()
- renameTo()
목록:
- list(), listFiles()
- listFiles(FileFilter)
- listFiles(FilenameFilter)
권한:
- setReadable(), setWritable(), setExecutable()
- setLastModified()
- setReadOnly()3.5 File 의 한계 (개요)
File 의 한계 (다음 섹션에서 정밀):
1. boolean 반환 — 진단 어려움
2. 디렉토리 자동 생성 안 함
3. 심볼릭 링크 처리 X
4. 풍부한 속성 X (POSIX 권한 등)
5. 비효율적 디렉토리 순회 (한 번에 전부)
6. 파일 시스템 추상화 X
7. 비동기 I/O X3.6 File 의 활용 (여전히 사용되는 곳)
// 1. 레거시 코드
public void legacyMethod(File file) {
// 기존 API 가 File 받음
}
// 2. 라이브러리 호환
SomeLibrary.process(new File("file.txt"));
// 3. 간단한 작업
File config = new File("config.properties");
if (config.exists()) {
// 처리
}
// 4. Path 와의 변환
File f = new File("file.txt");
Path p = f.toPath(); // Path 로 변환
Path p2 = Path.of("file.txt");
File f2 = p2.toFile(); // File 로 변환3.7 자기 점검 답변
File 객체의 본질과 구조는?
답:
1. 본질:
- 경로의 추상적 표현
- Java 1.0 부터
- 실제 파일과 별개
-
생성:
- 다양한 생성자 (경로 문자열, 부모+자식, URI)
- 파일 없어도 객체 생성
-
메서드 그룹:
- 정보 조회 (exists, length, ...)
- 경로 (getName, getAbsolutePath, ...)
- 생성/삭제 (createNewFile, delete, ...)
- 목록 (listFiles, ...)
- 권한 (setReadable, ...)
-
현재 권장:
- 새 코드: Path + Files
- File: 레거시 호환만
4️⃣ File 의 주요 메서드 정밀
4.1 createNewFile() — 파일 생성
File f = new File("/path/to/file.txt");
boolean created = f.createNewFile();
// 반환:
// - true: 성공적으로 생성
// - false: 이미 존재 또는 실패
// 예외:
// - IOException: I/O 실패 (디렉토리 없음, 권한 없음 등)
// 함정:
// - 부모 디렉토리가 없으면 IOException
// - "디렉토리는 자동 생성 안 됨"// 사용 패턴
File file = new File("/var/data/file.txt");
try {
if (file.createNewFile()) {
System.out.println("Created: " + file);
} else {
System.out.println("Already exists: " + file);
}
} catch (IOException e) {
// 부모 디렉토리 없음, 권한 없음 등
e.printStackTrace();
}
// NIO.2 의 대안
Path path = Path.of("/var/data/file.txt");
try {
Files.createFile(path);
} catch (FileAlreadyExistsException e) {
// 이미 존재
} catch (NoSuchFileException e) {
// 부모 디렉토리 없음 (명확!)
} catch (IOException e) {
// 기타
}4.2 getAbsolutePath() — 절대 경로
// 절대 경로 vs 상대 경로
// 상대 경로
File rel = new File("file.txt");
rel.getPath(); // file.txt (입력 그대로)
rel.getAbsolutePath(); // /current/dir/file.txt (현재 작업 디렉토리 기준)
// 절대 경로
File abs = new File("/home/user/file.txt");
abs.getPath(); // /home/user/file.txt
abs.getAbsolutePath(); // /home/user/file.txt (동일)
// getAbsolutePath 의 동작:
// 1. 이미 절대 경로면 그대로
// 2. 상대 경로면 user.dir 시스템 프로퍼티 prefix
// System.getProperty("user.dir")
// 주의:
// - 심볼릭 링크는 해소 안 함
// - . 과 .. 는 그대로 둠4.3 getCanonicalPath() — 정규화 경로
// Canonical = 정규화된 (심볼릭 링크 해소 + . / .. 정리)
File f = new File("/home/user/./docs/../file.txt");
f.getAbsolutePath(); // /home/user/./docs/../file.txt
f.getCanonicalPath(); // /home/user/file.txt (정규화)
// 심볼릭 링크
File link = new File("/path/to/symlink");
// 가정: /path/to/symlink → /real/path/file.txt
link.getAbsolutePath(); // /path/to/symlink
link.getCanonicalPath(); // /real/path/file.txt
// 예외:
// - IOException: 파일 시스템 접근 실패
// 활용:
// - 두 경로가 같은 파일을 가리키는지 비교
// - 보안 검사 (Path Traversal 방지)
File requested = new File(userInput);
File baseDir = new File("/var/data");
if (!requested.getCanonicalPath().startsWith(baseDir.getCanonicalPath())) {
// 안전하지 않음 — userInput 이 baseDir 외부
throw new SecurityException();
}4.4 getName() — 파일명만
File f = new File("/home/user/docs/report.pdf");
f.getName(); // report.pdf (파일명 + 확장자)
f.getPath(); // /home/user/docs/report.pdf
f.getParent(); // /home/user/docs
// 확장자 분리 (별도)
String name = f.getName();
int dot = name.lastIndexOf('.');
String base = (dot > 0) ? name.substring(0, dot) : name;
String ext = (dot > 0) ? name.substring(dot + 1) : "";
// NIO.2 의 대안
Path p = Path.of("/home/user/docs/report.pdf");
p.getFileName(); // report.pdf (Path 객체)
p.getFileName().toString(); // "report.pdf"4.5 getParent() — 부모 디렉토리
File f = new File("/home/user/docs/report.pdf");
f.getParent(); // "/home/user/docs" (String)
f.getParentFile(); // File 객체
// 루트의 경우
File root = new File("/");
root.getParent(); // null
root.getParentFile(); // null
// 상대 경로
File rel = new File("file.txt");
rel.getParent(); // null (부모가 명시 안 됨)
rel.getAbsoluteFile().getParent(); // 현재 작업 디렉토리
// 활용
File f = new File("/var/data/file.txt");
File dir = f.getParentFile();
if (!dir.exists()) {
dir.mkdirs(); // 부모 디렉토리 생성
}
f.createNewFile();4.6 length() — 파일 크기
File f = new File("file.txt");
long size = f.length();
// 반환:
// - 파일 크기 (바이트)
// - 파일 없으면 0
// - 디렉토리도 0 (대부분 OS)
// 함정:
// - 0 이 "비어있는 파일" 또는 "없는 파일" 둘 다 가능
// - 구분 필요: f.exists() + f.length()
if (f.exists()) {
if (f.length() == 0) {
// 빈 파일
} else {
// 데이터 있음
}
} else {
// 없는 파일
}4.7 lastModified() — 마지막 수정 시간
File f = new File("file.txt");
long timestamp = f.lastModified(); // millisecond since epoch
// 변환
Instant instant = Instant.ofEpochMilli(timestamp);
LocalDateTime dateTime = instant.atZone(ZoneId.systemDefault()).toLocalDateTime();
// 변경
f.setLastModified(System.currentTimeMillis());
// NIO.2 의 대안 (더 풍부)
Path p = Path.of("file.txt");
FileTime modifiedTime = Files.getLastModifiedTime(p);
Instant inst = modifiedTime.toInstant();4.8 listFiles() — 디렉토리 순회
File dir = new File("/var/data");
// 모든 파일 (배열, 한 번에 메모리에)
File[] all = dir.listFiles();
// 필터링
File[] txtFiles = dir.listFiles((d, name) -> name.endsWith(".txt"));
File[] regularFiles = dir.listFiles(File::isFile);
// 이름만
String[] names = dir.list();
// 함정:
// - 대용량 디렉토리에서 OOM 위험
// - null 반환 가능 (디렉토리 아니거나 접근 불가)
if (dir.isDirectory()) {
File[] files = dir.listFiles();
if (files != null) {
for (File f : files) { ... }
}
}
// NIO.2 의 대안 — Stream (lazy)
try (Stream<Path> paths = Files.list(Path.of("/var/data"))) {
paths.filter(p -> p.toString().endsWith(".txt"))
.forEach(System.out::println);
}4.9 ILIC 의 File 메서드 활용
public class ShipmentFileUtil {
private static final File EXPORT_DIR = new File("/var/shipment/exports");
// 파일 생성 (부모 디렉토리 자동 생성 포함)
public File createExportFile(String name) throws IOException {
// 부모 디렉토리 확인 + 생성
if (!EXPORT_DIR.exists() && !EXPORT_DIR.mkdirs()) {
throw new IOException("Cannot create directory: " + EXPORT_DIR);
}
File file = new File(EXPORT_DIR, name);
if (!file.createNewFile() && !file.exists()) {
throw new IOException("Cannot create file: " + file);
}
return file;
}
// 안전한 경로 확인 (Path Traversal 방지)
public File getSafeFile(String userInput) throws IOException {
File requested = new File(EXPORT_DIR, userInput);
String canonical = requested.getCanonicalPath();
String baseCanonical = EXPORT_DIR.getCanonicalPath();
if (!canonical.startsWith(baseCanonical)) {
throw new SecurityException("Path traversal attempt: " + userInput);
}
return requested;
}
// 오래된 파일 삭제
public void deleteOldFiles(int days) {
long threshold = System.currentTimeMillis() - (long) days * 24 * 3600 * 1000;
File[] files = EXPORT_DIR.listFiles();
if (files == null) return;
for (File f : files) {
if (f.isFile() && f.lastModified() < threshold) {
if (!f.delete()) {
log.warn("Failed to delete: {}", f);
}
}
}
}
}4.10 자기 점검 답변
File 의 주요 메서드 5가지의 정확한 차이는?
답:
1. createNewFile():
- 파일 생성
- 부모 디렉토리 없으면 IOException
- 이미 있으면 false
-
getAbsolutePath():
- 절대 경로 (user.dir 기준)
- 심볼릭 링크 해소 X
- . / .. 그대로
-
getCanonicalPath():
- 정규화 경로
- 심볼릭 링크 해소
- . / .. 정리
- IOException 가능
-
getName():
- 파일명만 (디렉토리 제외)
- 확장자 포함
-
getParent():
- 부모 디렉토리 (String)
- 루트면 null
- getParentFile() 은 File 반환
5️⃣ "디렉토리는 자동 생성 안 됨" 함정
5.1 가장 흔한 함정
// 가장 흔한 실수
File file = new File("/var/data/2026/05/report.txt");
try {
file.createNewFile();
// ❌ IOException: No such file or directory
// 부모 디렉토리 /var/data/2026/05 가 없음
} catch (IOException e) {
// 잡혔지만 원인 모름
}5.2 왜 자동 생성 안 하나?
이유:
1. 안전성
- 사용자가 의도하지 않은 디렉토리 생성 방지
- 권한 문제 회피
2. 명시성
- 디렉토리 생성은 명시적 의도
- mkdir() 또는 mkdirs() 호출
3. 성능
- 매번 디렉토리 검사는 비용
- 호출자가 알아서 보장
설계 결정:
- createNewFile() 은 단일 책임
- "파일 생성만"
- 부모 디렉토리는 별도5.3 mkdir 의 함정
// mkdir() — 단일 디렉토리만
File dir = new File("/var/data/2026/05/reports");
dir.mkdir();
// ❌ false
// 부모 /var/data/2026/05 가 없음
// mkdir 은 "마지막 하나만" 생성
// mkdirs() — 중간 디렉토리 모두
dir.mkdirs();
// ✓ true
// 필요한 모든 부모 디렉토리 생성
// /var/data/2026/05/reports
// /var/data/2026/05
// /var/data/2026
// /var/data
// 모두 생성 시도5.4 올바른 패턴
// 안전한 파일 생성 패턴
public File safeCreateFile(File file) throws IOException {
// 1. 부모 디렉토리 확보
File parent = file.getParentFile();
if (parent != null && !parent.exists()) {
if (!parent.mkdirs()) {
throw new IOException("Cannot create parent directory: " + parent);
}
}
// 2. 파일 생성
if (!file.createNewFile() && !file.exists()) {
throw new IOException("Cannot create file: " + file);
}
return file;
}
// 사용
File f = new File("/var/data/2026/05/report.txt");
safeCreateFile(f);
// 부모 디렉토리들 자동 생성5.5 NIO.2 의 해결
// NIO.2 의 createDirectories — 명시적, 명확
Path file = Path.of("/var/data/2026/05/report.txt");
Files.createDirectories(file.getParent()); // 부모 디렉토리 모두 생성
Files.createFile(file); // 파일 생성
// 또는 한 번에
Path file = Path.of("/var/data/2026/05/report.txt");
Files.createDirectories(file.getParent());
Files.writeString(file, "content");
// 이미 존재해도 OK (createDirectories)
// 첫 시도: 디렉토리 생성
// 두 번째 시도: 이미 존재, 그냥 통과5.6 실무에서 자주 발생하는 시나리오
// 시나리오 1: 날짜별 디렉토리에 저장
public class DailyExporter {
public void export(List<Shipment> shipments) throws IOException {
LocalDate today = LocalDate.now();
File dir = new File("/var/exports",
String.format("%d/%02d/%02d",
today.getYear(),
today.getMonthValue(),
today.getDayOfMonth()));
// ❌ 잊으면 IOException
// dir.exists() check + mkdirs() 누락
File file = new File(dir, "shipments.csv");
file.createNewFile(); // 실패!
// ✓ 올바른 패턴
if (!dir.exists()) {
dir.mkdirs();
}
// 또는 NIO.2
Files.createDirectories(dir.toPath());
}
}
// 시나리오 2: 업로드 파일 저장
public class FileUploader {
public void save(MultipartFile file, String userId) throws IOException {
File targetDir = new File("/var/uploads", userId);
// ❌ 누락
// targetDir.mkdirs();
File target = new File(targetDir, file.getOriginalFilename());
file.transferTo(target); // 실패!
// ✓ NIO.2
Path targetPath = Path.of("/var/uploads", userId, file.getOriginalFilename());
Files.createDirectories(targetPath.getParent());
file.transferTo(targetPath);
}
}
// 시나리오 3: 로그 파일 회전
public class LogRotator {
public void rotate(String logName) throws IOException {
File current = new File("/var/log", logName);
File archive = new File("/var/log/archive",
logName + "." + System.currentTimeMillis());
// ❌ /var/log/archive 가 없으면 실패
current.renameTo(archive);
// ✓ 올바른 패턴
Path archivePath = Path.of("/var/log/archive",
logName + "." + System.currentTimeMillis());
Files.createDirectories(archivePath.getParent());
Files.move(current.toPath(), archivePath);
}
}5.7 일반 원칙
파일 작업 전 체크리스트:
1. 부모 디렉토리 존재 확인
- 없으면 mkdirs() 또는 Files.createDirectories()
2. 권한 확인
- canWrite() 또는 Files.isWritable()
3. 디스크 공간 확인
- 큰 파일 작업 시 free space 확인
4. 파일 시스템 한계
- 파일명 길이
- 디렉토리 안 파일 수
5. 동시성
- 다른 프로세스가 동시 작업?
- Lock 필요?5.8 ILIC 의 안전한 파일 작업
@Component
public class SafeFileService {
private final Path baseDir = Path.of("/var/shipment");
public Path writeShipmentReport(String content, LocalDate date) throws IOException {
// 1. 날짜별 경로 생성
Path file = baseDir
.resolve("reports")
.resolve(String.valueOf(date.getYear()))
.resolve(String.format("%02d", date.getMonthValue()))
.resolve("shipment_" + date + ".txt");
// 2. 부모 디렉토리 보장
Files.createDirectories(file.getParent());
// 3. 권한 확인
if (!Files.isWritable(file.getParent())) {
throw new IOException("No write permission: " + file.getParent());
}
// 4. 안전한 쓰기 (이미 있으면 덮어쓰기)
Files.writeString(file, content,
StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);
return file;
}
public Path uploadShipmentAttachment(String userId, String filename, byte[] data)
throws IOException {
// 1. Path Traversal 방지
if (filename.contains("/") || filename.contains("..")) {
throw new SecurityException("Invalid filename: " + filename);
}
// 2. 사용자별 디렉토리
Path userDir = baseDir.resolve("uploads").resolve(userId);
Files.createDirectories(userDir);
// 3. 안전한 파일명 (timestamp 추가)
Path file = userDir.resolve(System.currentTimeMillis() + "_" + filename);
// 4. 쓰기
Files.write(file, data);
return file;
}
}5.9 자기 점검 답변
"디렉토리는 자동 생성 안 됨" 함정과 해결은?
답:
1. 함정:
file.createNewFile()가 부모 디렉토리 없으면 IOExceptionfile.renameTo(dest)도 dest 의 부모 디렉토리 필요- 업로드, 로그 회전 등에서 자주 발생
-
이유:
- 단일 책임 (파일 생성만)
- 안전성 (의도하지 않은 생성 방지)
-
해결:
mkdirs()(중간 디렉토리 모두)- 또는 NIO.2
Files.createDirectories()
-
권장 패턴:
Files.createDirectories(file.getParent()); Files.writeString(file, content); -
체크리스트:
- 부모 디렉토리 존재
- 권한
- 디스크 공간
- 동시성
6️⃣ mkdir vs mkdirs, 그 외 함정들
6.1 mkdir vs mkdirs
mkdir:
- 마지막 디렉토리만 생성
- 부모 없으면 실패 (false)
mkdirs:
- 필요한 모든 부모 디렉토리 생성
- 이미 있으면 그 부분은 건너뜀
- 최종 디렉토리도 이미 있으면 false// 비교
File dir = new File("/var/data/2026/05");
// 가정: /var 만 존재
dir.mkdir(); // false (부모 /var/data 없음)
dir.mkdirs(); // true (모두 생성)
// /var/data/2026/05 모두 생성됨
// 또 호출
dir.mkdir(); // false (이미 존재)
dir.mkdirs(); // false (이미 존재)
// 함정: mkdirs() 가 false 반환해도
// "이미 존재" 일 수도, "실패" 일 수도
// 구분 필요
if (!dir.mkdirs() && !dir.exists()) {
throw new IOException("Cannot create: " + dir);
}6.2 delete 의 함정
File dir = new File("/var/data");
// 디렉토리 안에 파일 있으면?
dir.delete(); // ❌ false (디렉토리가 비어있지 않음)
// 디렉토리 삭제 = 비어있을 때만
// 안의 파일/디렉토리 먼저 삭제 필요
// 재귀 삭제 (직접 구현 필요)
public static void deleteRecursively(File f) {
if (f.isDirectory()) {
File[] children = f.listFiles();
if (children != null) {
for (File child : children) {
deleteRecursively(child);
}
}
}
f.delete();
}
// NIO.2 의 대안
Files.walkFileTree(Path.of("/var/data"), new SimpleFileVisitor<Path>() {
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
Files.delete(file);
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
Files.delete(dir);
return FileVisitResult.CONTINUE;
}
});
// 또는 Apache Commons IO
FileUtils.deleteDirectory(new File("/var/data"));6.3 renameTo 의 함정
File src = new File("/var/data/file.txt");
File dest = new File("/other/dir/file.txt");
boolean renamed = src.renameTo(dest);
// 함정 1: 부모 디렉토리 없음
// /other/dir 없으면 false
// 함정 2: 다른 파일 시스템
// /var 와 /other 가 다른 마운트 포인트면 실패 가능
// 일부 OS
// 함정 3: 이미 존재
// dest 가 이미 있으면 OS 따라 다름
// 함정 4: 실패 원인 모름
// false 만 반환
// NIO.2 의 대안
Files.move(src.toPath(), dest.toPath());
// 명확한 예외:
// - NoSuchFileException
// - FileAlreadyExistsException
// - AtomicMoveNotSupportedException
// 옵션
Files.move(src.toPath(), dest.toPath(),
StandardCopyOption.REPLACE_EXISTING,
StandardCopyOption.ATOMIC_MOVE);6.4 listFiles 의 함정
File dir = new File("/var/data");
// 함정 1: null 반환
File[] files = dir.listFiles();
// - 디렉토리 아님
// - 접근 권한 없음
// - I/O 에러
// 모두 null
// 안전한 사용
File[] files = dir.listFiles();
if (files != null) {
for (File f : files) { ... }
}
// 함정 2: 메모리 사용
// 1만 파일 = 1만 File 객체 한 번에 메모리
// 대용량 디렉토리에서 OOM 위험
// NIO.2 의 대안 — Stream
try (Stream<Path> paths = Files.list(Path.of("/var/data"))) {
paths.forEach(System.out::println);
}
// Lazy, 메모리 효율6.5 경로 구분자
// OS 별 경로 구분자
// Windows: \
// Unix/Linux/Mac: /
// File 사용 시
File f1 = new File("/home/user/file.txt"); // Unix
File f2 = new File("C:\\Users\\user\\file.txt"); // Windows
// 구분자 가져오기
String sep = File.separator;
// Windows: "\\"
// Unix: "/"
// File 은 OS 자동 변환
File f3 = new File("/home/user");
File f4 = new File(f3, "docs");
f4.getPath();
// Unix: /home/user/docs
// Windows: \home\user\docs
// NIO.2 의 일관된 처리
Path p = Path.of("/home/user/docs");
// 또는 multi-arg
Path p2 = Path.of("/home", "user", "docs");
// OS 자동 처리6.6 파일 존재 확인의 race condition
// 함정: TOCTOU (Time-Of-Check Time-Of-Use)
File f = new File("file.txt");
if (f.exists()) {
// ★ 여기서 다른 프로세스가 삭제할 수 있음
f.delete(); // 실패 가능
}
// 더 안전: 직접 시도 + 예외 처리
try {
Files.delete(Path.of("file.txt"));
} catch (NoSuchFileException e) {
// 없음
} catch (IOException e) {
// 기타
}6.7 File 의 동시성
// File 자체는 immutable (경로만)
// 하지만 가리키는 파일은 외부 자원
File f = new File("file.txt");
// 동시에 여러 스레드가 작업
Thread t1 = new Thread(() -> writeToFile(f));
Thread t2 = new Thread(() -> readFromFile(f));
// 동기화 필요 (외부 자원)
// 1. 파일 락
// 2. 애플리케이션 락
// 3. NIO.2 의 FileLock
// FileLock 활용
try (FileChannel ch = FileChannel.open(f.toPath(), READ, WRITE);
FileLock lock = ch.lock()) {
// 배타적 락
// ...
}6.8 흔한 실수 종합
File 사용 시 흔한 실수:
1. 부모 디렉토리 안 만들고 createNewFile
2. mkdir vs mkdirs 혼동
3. delete 의 디렉토리 비어있어야 함
4. renameTo 의 부모 디렉토리 누락
5. listFiles 의 null 체크 누락
6. 대용량 디렉토리 listFiles
7. 경로 구분자 하드코딩
8. TOCTOU race condition
9. 동시성 무시
10. 진단 어려움 (boolean 반환)
→ 대부분 NIO.2 의 Path/Files 에서 명시적 예외로 해결6.9 자기 점검 답변
File 사용 시 함정 5가지는?
답:
1. 디렉토리 자동 생성 X: mkdirs() 필수
2. mkdir vs mkdirs: 단일 vs 중간 모두
3. delete 의 디렉토리: 비어있어야
4. renameTo 의 부모 누락: dest 부모 디렉토리 필요
5. listFiles 의 null: 권한/오류 시 null
해결: NIO.2 의 Files API
- Files.createDirectories
- Files.delete (NoSuchFileException)
- Files.move (FileAlreadyExistsException)
- Files.list (Stream)
7️⃣ File 의 한계 종합 + NIO.2 해결
7.1 File 의 한계 7가지
File 의 7가지 한계:
1. boolean 반환 — 진단 어려움
2. 디렉토리 자동 생성 안 함
3. 심볼릭 링크 처리 X
4. 풍부한 속성 X
5. 비효율적 디렉토리 순회
6. 파일 시스템 추상화 X
7. 비동기 I/O X7.2 NIO.2 의 해결
| 한계 | File | NIO.2 |
|---|---|---|
| 에러 처리 | boolean | 구체적 예외 |
| 디렉토리 | mkdirs | Files.createDirectories |
| 심볼릭 링크 | exists 모호 | LinkOption.NOFOLLOW_LINKS |
| 속성 | length, lastModified | BasicFileAttributes, PosixFileAttributes |
| 순회 | listFiles (메모리) | Files.list (Stream) |
| 파일 시스템 | 로컬만 | FileSystems (ZIP 등) |
| 비동기 | X | AsynchronousFileChannel |
7.3 명확한 예외 계층
NIO.2 의 예외 계층:
IOException
├── NoSuchFileException - 파일 없음
├── FileAlreadyExistsException - 이미 존재
├── AccessDeniedException - 권한 없음
├── DirectoryNotEmptyException - 디렉토리 비어있지 않음
├── NotDirectoryException - 디렉토리가 아님
├── FileSystemException - 파일 시스템 일반
├── AtomicMoveNotSupportedException - 원자적 이동 불가
└── ClosedFileSystemException - 닫힌 FS
활용:
try {
Files.delete(path);
} catch (NoSuchFileException e) {
// 명확
} catch (DirectoryNotEmptyException e) {
// 명확
} catch (AccessDeniedException e) {
// 명확
}7.4 풍부한 속성
// File 의 빈약한 속성
File f = new File("file.txt");
f.length();
f.lastModified();
f.canRead();
f.canWrite();
// 끝
// NIO.2 의 풍부한 속성
Path p = Path.of("file.txt");
// 기본 속성
BasicFileAttributes basic = Files.readAttributes(p, BasicFileAttributes.class);
basic.creationTime();
basic.lastAccessTime();
basic.lastModifiedTime();
basic.size();
basic.isRegularFile();
basic.isDirectory();
basic.isSymbolicLink();
basic.fileKey();
// POSIX 속성 (Linux/Mac)
PosixFileAttributes posix = Files.readAttributes(p, PosixFileAttributes.class);
posix.owner();
posix.group();
posix.permissions();
// Set<PosixFilePermission>
// DOS 속성 (Windows)
DosFileAttributes dos = Files.readAttributes(p, DosFileAttributes.class);
dos.isHidden();
dos.isReadOnly();
dos.isSystem();
// 권한 변경
Set<PosixFilePermission> perms = EnumSet.of(
PosixFilePermission.OWNER_READ,
PosixFilePermission.OWNER_WRITE);
Files.setPosixFilePermissions(p, perms);7.5 심볼릭 링크 처리
// NIO.2 의 심볼릭 링크 정밀
Path link = Path.of("/path/to/symlink");
// 링크 자체 검사
boolean linkExists = Files.exists(link, LinkOption.NOFOLLOW_LINKS);
// 원본 검사 (기본)
boolean targetExists = Files.exists(link);
// 링크 vs 원본 구분
Files.isSymbolicLink(link); // true
Files.isRegularFile(link); // false (링크니까)
Files.isRegularFile(link, LinkOption.NOFOLLOW_LINKS); // 옵션
// 링크 따라가서 원본 정보
Path real = link.toRealPath(); // 원본 경로
// 링크 자체 정보
Path target = Files.readSymbolicLink(link); // 가리키는 경로
// 링크 생성
Files.createSymbolicLink(link, target);
Files.createLink(link, target); // 하드 링크7.6 효율적 순회
// File 의 비효율
File dir = new File("/large/dir");
File[] all = dir.listFiles(); // 메모리에 모두
// NIO.2 의 Stream
try (Stream<Path> paths = Files.list(Path.of("/large/dir"))) {
paths.filter(p -> p.toString().endsWith(".txt"))
.limit(100)
.forEach(System.out::println);
}
// Lazy, 메모리 효율적
// 재귀 (walk)
try (Stream<Path> paths = Files.walk(Path.of("/large/dir"))) {
long count = paths.filter(Files::isRegularFile).count();
}
// 조건 (find)
try (Stream<Path> paths = Files.find(
Path.of("/large/dir"), 5, // 깊이 5
(path, attrs) -> attrs.size() > 1_000_000)) {
paths.forEach(System.out::println);
}
// FileVisitor (가장 정밀)
Files.walkFileTree(Path.of("/large/dir"), new SimpleFileVisitor<Path>() {
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
if (attrs.size() > 1_000_000) {
System.out.println(file);
}
return FileVisitResult.CONTINUE;
}
});7.7 파일 시스템 추상화
// ZIP 파일을 파일 시스템처럼
try (FileSystem zipFs = FileSystems.newFileSystem(
Path.of("archive.zip"), Map.of())) {
// ZIP 안의 파일 작업
Path inZip = zipFs.getPath("/inside/file.txt");
String content = Files.readString(inZip);
// 새 파일 추가 (실제 ZIP 수정)
Path newFile = zipFs.getPath("/added.txt");
Files.writeString(newFile, "new content");
// 디렉토리 순회
try (Stream<Path> paths = Files.walk(zipFs.getPath("/"))) {
paths.forEach(System.out::println);
}
}
// 동일 API 로 다양한 FS 사용
// - 로컬 FS
// - ZIP
// - JAR
// - 메모리 (jimfs 같은 라이브러리)
// - 네트워크 FS7.8 비동기 I/O
// NIO.2 의 비동기 파일 채널
AsynchronousFileChannel channel = AsynchronousFileChannel.open(
Path.of("file.txt"), StandardOpenOption.READ);
ByteBuffer buffer = ByteBuffer.allocate(1024);
// 방법 1: Future
Future<Integer> future = channel.read(buffer, 0);
// 즉시 리턴, 백그라운드 진행
while (!future.isDone()) {
// 다른 일
}
int bytesRead = future.get();
// 방법 2: CompletionHandler (콜백)
channel.read(buffer, 0, "attachment",
new CompletionHandler<Integer, String>() {
@Override
public void completed(Integer result, String attachment) {
System.out.println("Read " + result + " bytes");
}
@Override
public void failed(Throwable exc, String attachment) {
exc.printStackTrace();
}
});7.9 ILIC 의 마이그레이션
// 옛 코드 (File 기반)
public class OldFileService {
public void process(String dirPath, String fileName) throws IOException {
File dir = new File(dirPath);
if (!dir.exists() && !dir.mkdirs()) {
throw new IOException("Cannot create directory");
}
File file = new File(dir, fileName);
if (!file.createNewFile() && !file.exists()) {
throw new IOException("Cannot create file");
}
// 처리
try (FileWriter writer = new FileWriter(file)) {
writer.write("data");
}
}
}
// 새 코드 (Path + Files)
public class NewFileService {
public void process(String dirPath, String fileName) throws IOException {
Path file = Path.of(dirPath, fileName);
Files.createDirectories(file.getParent());
Files.writeString(file, "data");
// 명확, 간결
}
}
// 점진적 마이그레이션
// 1. File ↔ Path 변환 활용
// 2. 새 메서드만 Path 로
// 3. 점진적으로 옛 코드 교체7.10 자기 점검 답변
File 의 한계와 NIO.2 의 해결은?
답:
1. 에러 처리: boolean → 구체적 예외
2. 디렉토리: mkdirs → Files.createDirectories
3. 심볼릭 링크: 모호 → LinkOption
4. 속성: 빈약 → BasicFileAttributes, PosixFileAttributes
5. 순회: 메모리 → Stream
6. FS 추상화: 로컬만 → FileSystem (ZIP 등)
7. 비동기: X → AsynchronousFileChannel
권장:
- 새 코드: Path + Files
- 레거시: File 유지 또는 점진 마이그레이션
- File ↔ Path 변환 메서드 활용
8️⃣ Phase 7 완주 정리 + Phase 8 예고
8.1 Phase 7 학습 종합
Phase 7 — I/O 시스템 큰 그림
Unit 7.1 — I/O 란 무엇인가
- JVM 기준 Input/Output
- I/O 의 4가지 종류
- 자바 I/O 진화 (1.0 → 1.4 → 7)
- I/O 모델 4가지 (Blocking/Non-blocking × Sync/Async)
Unit 7.2 — IO vs NIO (역사적 진화)
- 3 시대 비교
- File vs Files
- Decorator 패턴
- 채널 + 버퍼
Unit 7.3 — Stream vs Channel
- Buffer 의 4속성 정밀
- Heap vs Direct Buffer
- zero-copy
- MappedByteBuffer
Unit 7.4 — Blocking vs Non-blocking (★ 마스터)
- OS 레벨 동작
- Selector 정밀
- 동시성 모델 4가지
- 1만 연결 시나리오
- Tomcat/Netty/WebFlux/Loom
Unit 7.5 — 오버헤드와 File 객체
- 오버헤드의 정의
- I/O 오버헤드 4지점
- File 메서드 정밀
- 자주 발생하는 함정8.2 Phase 7 마스터 후 가능한 일
1. I/O 모델 선택
- 시나리오 분석
- Blocking/Non-blocking/Reactive/Loom 선택
2. 효율적 파일 작업
- Stream 활용
- Buffered + Direct Buffer
- zero-copy
3. 대규모 동시 연결
- Selector, Netty 이해
- WebFlux 활용
- Project Loom
4. 함정 회피
- 디렉토리 자동 생성 X
- mkdir vs mkdirs
- listFiles null
- TOCTOU race condition
5. 마이그레이션
- File → Path
- 점진적 전환
- 변환 메서드 활용
6. 면접 자신감
- I/O 의 본질
- JVM 기준 I/O
- 동시성 모델
- C10K 문제
- 자바 I/O 의 진화8.3 Phase 7 의 큰 그림
I/O 의 본질:
- JVM 기준 데이터 흐름
- 외부 ↔ 내부
3 시대 진화:
IO (1.0) → NIO (1.4) → NIO.2 (7)
- 단방향 → 양방향
- Blocking → Non-blocking
- File → Path + Files
동시성:
- Thread-per-connection (단순, 한계)
- Event Loop (효율, 복잡)
- Reactive (함수형)
- Virtual Threads (미래)
실무 함정:
- 디렉토리 자동 생성 X
- 예외 마스킹
- 메모리 효율 (Stream vs 배열)
- 자원 누수8.4 Phase 8 — Stream 실전
다음 Phase 는 자바 IO Stream 의 실전.
Phase 8 — Stream 실전 (6 Unit)
Unit 8.1 — System.in (한글 안 되는 이유)
- System.in 의 정체
- 1바이트씩 vs 한글
- 인코딩 이슈
Unit 8.2 — FileInputStream
- 파일 바이트 스트림
- read() 의 정밀
- 파일 끝 (-1)
Unit 8.3 — byte[] 배열로 효율적 읽기
- 버퍼링
- 마지막 읽기 함정 (n 만큼만)
Unit 8.4 — FileOutputStream
- 파일 쓰기
- 이어쓰기 모드 (append)
- 인코딩 매핑
Unit 8.5 — 한글 처리 (FileReader, InputStreamReader)
- Reader vs InputStream
- 인코딩 명시
- 두 방식 비교
Unit 8.6 — FileWriter (한글 쓰기)
- Writer 의 정밀
- 다양한 write 메서드8.5 Phase 7 → Phase 8 의 연결
Phase 7: I/O 의 큰 그림 (개념)
↓
Phase 8: Stream 의 실전 (코드)
↓
Phase 9: Stream 의 강화 (Buffered/Data/Serialization)
↓
Phase 10: 함수형 (람다, Stream API)
연결:
- Phase 7 의 개념을 Phase 8 에서 코드로
- Phase 8 의 기본 위에 Phase 9 의 보조 스트림
- Phase 10 의 함수형 Stream API (다른 개념)8.6 3주차 누적 진행
✅ Phase 1 — Pass by Value (1.1 ~ 1.3 완주, 3 Unit)
✅ Phase 2 — 컬렉션 프레임워크 (2.1 ~ 2.6 완주, 6 Unit)
✅ Phase 3 — 해시의 원리 (3.1 ~ 3.4 완주, 4 Unit)
✅ Phase 4 — 추상화의 두 도구 (4.1 ~ 4.4 완주, 4 Unit)
✅ Phase 5 — 제네릭과 와일드카드 (5.1 ~ 5.5 완주, 5 Unit)
✅ Phase 6 — 객체 비교 (6.1 ~ 6.4 완주, 4 Unit)
✅ Phase 7 — I/O 시스템 큰 그림 (7.1 ~ 7.5 완주, 5 Unit) ← 여기
🚀 Phase 8 — Stream 실전 (6 Unit 예정)
⏭ Phase 9 — I/O 강화 (5 Unit)
⏭ Phase 10 — 함수형 프로그래밍 (4 Unit)
총: 31/43 Unit 작성 (Phase 7 완주, 약 72%)8.7 자기 점검 답변
Phase 7 학습의 종합은?
답:
1. 개념:
- I/O = JVM 기준 데이터 흐름
- 자바 I/O 의 3 시대
- Stream vs Channel
-
정밀:
- Buffer 의 4속성
- Heap vs Direct
- zero-copy
-
동시성:
- Blocking vs Non-blocking
- Selector 의 멀티플렉싱
- 4가지 모델 (Thread/Event/Reactive/Loom)
-
실무:
- 오버헤드 4지점
- File 의 한계
- 함정 회피
- NIO.2 권장
-
미래:
- Project Loom (Virtual Threads)
- 동기 코드 + 효율
- 새 표준
9️⃣ 면접 + 자기 점검
9.1 면접 단골 질문 매핑
| Q | 핵심 답변 |
|---|---|
| 오버헤드 정의? | 본 작업 외 간접 비용 |
| I/O 오버헤드 4지점? | 시스템 호출, 컨텍스트 스위칭, 버퍼 복사, 추상화 |
| File 정의? | 경로의 추상화, Java 1.0+ |
| createNewFile vs Files.createFile? | boolean vs 예외 |
| getAbsolutePath vs getCanonicalPath? | 절대 경로 vs 정규화 (심볼릭 링크 해소) |
| 디렉토리 자동 생성? | X — mkdirs() 또는 Files.createDirectories() |
| mkdir vs mkdirs? | 단일 vs 중간 모두 |
| File 의 한계 7가지? | boolean/디렉토리/심볼릭/속성/순회/FS/비동기 |
| listFiles null? | 권한, 오류, 디렉토리 아님 |
| File → Path? | toPath(), Path.of |
| TOCTOU? | 시간차 race condition |
9.2 자기 점검 체크리스트
오버헤드
- 정의와 4가지 종류
- I/O 오버헤드 4지점
- 좋은 vs 나쁜 오버헤드
- 측정 방법
File 기본
- File 정의와 본질
- 5가지 생성자
- 주요 메서드 그룹
- File ↔ Path 변환
File 메서드 정밀
- createNewFile
- getAbsolutePath vs getCanonicalPath
- getName, getParent
- length, lastModified
- listFiles, list
함정
- 디렉토리 자동 생성 X
- mkdir vs mkdirs
- delete (디렉토리 비어야)
- renameTo (부모 디렉토리)
- listFiles null
- TOCTOU
- 동시성
한계와 NIO.2
- File 의 7가지 한계
- 명확한 예외 계층
- BasicFileAttributes
- Files.list/walk
- FileSystem 추상화
- 비동기 I/O
9.3 추가 심화 질문
Q1: getCanonicalPath 가 IOException 던지는 이유?
답:
- 파일 시스템 접근 필요 (심볼릭 링크 해소)
- 실제 파일 시스템 조회
- 권한 부족, I/O 에러 가능
- getAbsolutePath 는 문자열 처리만 (IOException X)
Q2: File.deleteOnExit() 의 동작?
답:
File temp = new File("temp.txt");
temp.deleteOnExit();
// JVM 종료 시 자동 삭제
// 단, 정상 종료만 (kill -9 같은 강제 종료는 X)- 임시 파일 정리에 유용
- 단, 신뢰성 100% 아님
Q3: File.equals 의 동작?
답:
- 경로 문자열 비교 (정확히 같은지)
- OS 의 대소문자 구분 따름
- 심볼릭 링크 해소 X
- 다른 경로지만 같은 파일이면 equals = false
File f1 = new File("/path/file.txt");
File f2 = new File("/path/./file.txt");
f1.equals(f2); // false (다른 경로 문자열)
// 동일성 비교는
f1.getCanonicalFile().equals(f2.getCanonicalFile()); // trueQ4: 임시 파일 생성?
답:
// File
File temp = File.createTempFile("prefix", ".txt");
// /tmp/prefix12345.txt 같은
temp.deleteOnExit();
// NIO.2
Path temp = Files.createTempFile("prefix", ".txt");
Path tempDir = Files.createTempDirectory("dirPrefix");
// 사용 후 삭제 권장
try (Stream<...> s = ...) {
// 처리
} finally {
Files.deleteIfExists(temp);
}Q5: File 클래스가 deprecated 되나?
답:
- 현재 deprecated 아님
- 하위 호환성을 위해 유지
- 새 코드는 Path 권장
- 자바 표준 라이브러리는 둘 다 지원
// FileInputStream 도 Path 받음 (Java 7+)
FileInputStream fis = new FileInputStream("file.txt");
// 그래도 NIO.2 권장
InputStream is = Files.newInputStream(Path.of("file.txt"));🎯 핵심 요약 — 3줄 정리
1. 오버헤드와 I/O
- 오버헤드: 본 작업 외 간접 비용
- I/O 의 4지점: 시스템 호출, 컨텍스트 스위칭, 버퍼 복사, 추상화
- Buffered, Direct Buffer, zero-copy 로 절감
2. File 의 한계
- boolean 반환 (진단 어려움)
- 디렉토리 자동 생성 X
- 풍부한 속성 X
- 함정: mkdirs 누락, listFiles null
3. NIO.2 가 해결
- 구체적 예외 (NoSuchFileException 등)
- Files.createDirectories
- BasicFileAttributes
- Stream 기반 순회
🏆 Phase 7 완주 — I/O 시스템 마스터 달성
🚀 Phase 7 — I/O 시스템 큰 그림
✅ Unit 7.1 I/O 란 무엇인가
✅ Unit 7.2 IO vs NIO (역사적 진화)
✅ Unit 7.3 Stream vs Channel
✅ Unit 7.4 Blocking vs Non-blocking (★ 마스터 깊이)
✅ Unit 7.5 오버헤드와 File 객체 ← 여기, Phase 7 완주
→ 자바 I/O 시스템 정복
→ JVM 기준 I/O 의 본질
→ 3 시대 진화 (IO/NIO/NIO.2)
→ 동시성 모델 4가지 마스터
→ 실무 함정 회피📚 다음으로...
Phase 8 — Stream 실전
다음 Phase 는 자바 IO Stream 의 실전.
Phase 8 — Stream 실전 (6 Unit)
Unit 8.1 — System.in (한글 안 되는 이유)
Unit 8.2 — FileInputStream
Unit 8.3 — byte[] 배열로 효율적 읽기
Unit 8.4 — FileOutputStream
Unit 8.5 — 한글 처리 (FileReader, InputStreamReader)
Unit 8.6 — FileWriter (한글 쓰기)Phase 7 와의 연결:
- Phase 7: I/O 개념
- Phase 8: Stream 의 실전 코드
- Reader/Writer 의 정확한 활용
- 한글 (인코딩) 의 정밀
Software Developer