Unit 8.5 — 한글 처리 (FileReader, InputStreamReader)
F-LAB JAVA · 3주차 · Phase 8 · Stream 실전
📌 학습 목표
이 Unit을 끝내면 다음을 답할 수 있어야 한다.
- Reader 의 정의와 InputStream 과의 결정적 차이 는?
- FileReader 의 정의와 한계는?
- InputStreamReader 의 정의와 활용은?
- FileReader vs InputStreamReader 의 선택 기준은?
- 인코딩 명시의 중요성 과 명시 안 하면 어떻게 되나?
- BufferedReader 와 결합의 효과는?
- char 의 한계 (Supplementary 문자, 이모지) 는?
- Java 11+ 의 FileReader(File, Charset) 의 의미는?
- 실무 권장 패턴 은?
🎯 핵심 한 문장
Reader는 문자 (char) 단위로 읽는 추상 클래스로, 인코딩을 인식 하여 바이트 시퀀스를 문자로 변환한다.
FileReader는 파일 전용 Reader 지만 Java 10 까지 인코딩 명시 불가 (시스템 기본만) — Cross-platform 위험.
InputStreamReader는InputStream을Reader로 변환하며 인코딩 명시 가능 — 실무 권장.
BufferedReader를 결합하면 readLine 으로 줄 단위 처리 + 버퍼링 효율.
Java 11+ 부터FileReader(File, Charset)생성자 추가로 FileReader 도 안전하게 사용 가능, 하지만Files.newBufferedReader(path, UTF_8)가 가장 권장.
비유 — 외국어 책 번역가
InputStream:
외국어 책의 글자 사진을 한 장씩 보는 사람
- 사진 1장 = 1바이트
- 한글 "안" = 사진 3장 따로
- 의미 모름
Reader:
사전 (인코딩) 을 가진 번역가
- 사진 1~4장을 보고 1 문자
- 한글 "안" = "안" 으로 인식
- 의미 있음
FileReader (옛):
사전을 항상 한국에서 가져옴 (시스템 기본)
- 외국 가면 사전이 달라짐
- Cross-platform 위험
InputStreamReader (안전):
사전을 명시 ("UTF-8" 사전 사용)
- 어디서든 같은 사전
- 안전→ Reader = 인코딩 인식 + 문자 단위.
🧭 9개 섹션 로드맵
1. Reader 의 정의와 InputStream 과의 차이
2. FileReader 의 정의와 한계
3. InputStreamReader 의 정의와 활용
4. FileReader vs InputStreamReader 비교
5. 인코딩 명시의 중요성
6. BufferedReader 와의 결합
7. char 의 한계 (Supplementary 문자)
8. Java 11+ 의 개선과 실무 패턴
9. 면접 + 자기 점검1️⃣ Reader 의 정의와 InputStream 과의 차이
1.1 Reader 의 정의
public abstract class Reader implements Readable, Closeable {
// 핵심 메서드
public int read() throws IOException;
public int read(char[] cbuf) throws IOException;
public abstract int read(char[] cbuf, int off, int len) throws IOException;
// 추가
public long skip(long n) throws IOException;
public boolean ready() throws IOException;
public boolean markSupported();
public void mark(int readAheadLimit) throws IOException;
public void reset() throws IOException;
public abstract void close() throws IOException;
}핵심:
- 문자 (char) 단위 처리
- 인코딩 인식
java.io패키지- Java 1.1 부터
1.2 Reader 의 계층
Reader (추상)
├── InputStreamReader ← InputStream 을 Reader 로
│ └── FileReader ← 파일 전용
├── BufferedReader ← 버퍼링 + readLine
├── StringReader ← String 을
├── CharArrayReader ← char[] 를
├── PipedReader ← 파이프
└── FilterReader
└── PushbackReader
핵심:
- 모두 char 처리
- InputStream 의 byte 와 대응1.3 InputStream vs Reader 결정적 차이
| 항목 | InputStream | Reader |
|---|---|---|
| 단위 | byte (8비트) | char (16비트) |
| 인코딩 | X (raw) | ✓ (자동 변환) |
| 반환 (read) | 0~255, -1 | 0~65535, -1 |
| 한글 처리 | 불가 (1바이트) | OK (인코딩 매핑) |
| 패키지 | java.io | java.io |
| 자식 | FileInputStream 등 | FileReader 등 |
1.4 read() 의 비교
// InputStream.read()
InputStream is = new FileInputStream("file.txt");
int b = is.read();
// 반환: 0~255 (byte 의 unsigned 값) 또는 -1
// 1바이트 (한글이면 분리됨)
// Reader.read()
Reader r = new InputStreamReader(new FileInputStream("file.txt"), "UTF-8");
int c = r.read();
// 반환: 0~65535 (char 의 값) 또는 -1
// 1문자 (한글 1글자 = 1 read)1.5 한글 처리 비교
// 파일 내용: "안" (UTF-8: EC 95 88)
// InputStream — 3번 read
try (FileInputStream fis = new FileInputStream("an.txt")) {
int b1 = fis.read(); // 236 (0xEC)
int b2 = fis.read(); // 149 (0x95)
int b3 = fis.read(); // 136 (0x88)
// 각각 따로 → 의미 잃음
}
// Reader — 1번 read
try (Reader r = new InputStreamReader(
new FileInputStream("an.txt"), "UTF-8")) {
int c = r.read(); // 51008 (0xC548 = '안')
char ch = (char) c; // '안'
// 한 글자 완성
}1.6 시각적 비교
파일: "안녕" (UTF-8, 6바이트)
InputStream.read() 시퀀스:
236, 149, 136, ← "안" 의 3바이트
235, 133, 149, ← "녕" 의 3바이트
-1 ← EOF
Reader.read() 시퀀스:
'안' (51008), ← "안" 1문자
'녕' (45397), ← "녕" 1문자
-1 ← EOF1.7 ILIC 의 활용 비교
// ❌ InputStream 으로 한글 (잘못)
public String readKoreanBad(Path path) throws IOException {
StringBuilder sb = new StringBuilder();
try (FileInputStream fis = new FileInputStream(path.toFile())) {
int b;
while ((b = fis.read()) != -1) {
sb.append((char) b);
// 한글 깨짐!
}
}
return sb.toString();
}
// ✓ Reader 로 한글
public String readKoreanGood(Path path) throws IOException {
StringBuilder sb = new StringBuilder();
try (Reader r = new InputStreamReader(
new FileInputStream(path.toFile()),
StandardCharsets.UTF_8)) {
int c;
while ((c = r.read()) != -1) {
sb.append((char) c);
}
}
return sb.toString();
}
// ✓✓ BufferedReader (더 효율적)
public String readKoreanBest(Path path) throws IOException {
try (BufferedReader r = Files.newBufferedReader(path, StandardCharsets.UTF_8)) {
return r.lines().collect(Collectors.joining("\n"));
}
}1.8 자기 점검 답변
Reader 와 InputStream 의 결정적 차이는?
답:
1. 단위:
- InputStream: byte (1바이트)
- Reader: char (1문자)
-
인코딩:
- InputStream: raw, 인코딩 X
- Reader: 자동 변환
-
한글 처리:
- InputStream: 불가 (3바이트 분리)
- Reader: 가능 (1 read = 1글자)
-
반환:
- InputStream.read(): 0~255
- Reader.read(): 0~65535 (char 범위)
-
권장:
- 텍스트: Reader
- 바이너리: InputStream
2️⃣ FileReader 의 정의와 한계
2.1 FileReader 의 정의
package java.io;
public class FileReader extends InputStreamReader {
public FileReader(String fileName) throws FileNotFoundException;
public FileReader(File file) throws FileNotFoundException;
public FileReader(FileDescriptor fd);
// Java 11+ 추가
public FileReader(String fileName, Charset charset) throws IOException;
public FileReader(File file, Charset charset) throws IOException;
}핵심:
- InputStreamReader 의 자식
- 파일 전용
- Java 10 까지는 인코딩 명시 불가
- Java 11+ 부터 Charset 생성자 추가
2.2 기본 사용 (Java 10 이하)
// Java 10 이하 — 인코딩 명시 불가
try (FileReader reader = new FileReader("file.txt")) {
int c;
while ((c = reader.read()) != -1) {
System.out.print((char) c);
}
}
// 문제:
// - 시스템 기본 인코딩 사용
// - Windows: MS949
// - Linux/Mac: UTF-8
// - Cross-platform 위험!2.3 시스템 기본 인코딩의 함정
// 시나리오: UTF-8 파일을 Windows 에서 읽기
// 파일: "안녕" (UTF-8 으로 저장됨)
// Windows 의 자바 (MS949)
try (FileReader reader = new FileReader("hello.txt")) {
// 기본 인코딩 = MS949
// UTF-8 파일을 MS949 로 해석
// → 깨짐!
}
// Linux 의 자바 (UTF-8)
try (FileReader reader = new FileReader("hello.txt")) {
// 기본 인코딩 = UTF-8
// 정상 처리
}
// 같은 코드, 다른 결과
// → FileReader 의 큰 함정2.4 Java 11+ 의 개선
// Java 11+ 부터 인코딩 명시 가능
try (FileReader reader = new FileReader("file.txt", StandardCharsets.UTF_8)) {
int c;
while ((c = reader.read()) != -1) {
System.out.print((char) c);
}
}
// 이제 안전:
// - 모든 OS 에서 UTF-8
// - Cross-platform 일관성2.5 FileReader 의 한계 (여전히)
한계:
1. 인코딩 명시 (Java 10 이하) 불가
- Java 11+ 에서 해결
2. NIO.2 API 활용 어려움
- Path 대신 String/File 만
3. BufferedReader 와 결합해야 효율
- 단독으로는 1문자씩
4. Files.newBufferedReader 가 더 권장
- 더 간결, NIO.2 통합2.6 FileReader 의 실제 활용
// 짧은 텍스트 파일 — 간단할 때
try (FileReader reader = new FileReader("config.txt", StandardCharsets.UTF_8)) {
// 간단한 한 문자씩 처리
}
// 더 권장 — BufferedReader 결합
try (BufferedReader reader = new BufferedReader(
new FileReader("file.txt", StandardCharsets.UTF_8))) {
String line;
while ((line = reader.readLine()) != null) {
// 한 줄씩 처리
}
}
// 가장 권장 — NIO.2
try (BufferedReader reader = Files.newBufferedReader(
Path.of("file.txt"), StandardCharsets.UTF_8)) {
String line;
while ((line = reader.readLine()) != null) {
// 처리
}
}2.7 ILIC 의 FileReader 활용
public class ShipmentTextReader {
// Java 11+ 에서 안전
public String readShipmentText(Path path) throws IOException {
try (FileReader reader = new FileReader(path.toFile(), StandardCharsets.UTF_8);
BufferedReader br = new BufferedReader(reader)) {
return br.lines().collect(Collectors.joining("\n"));
}
}
// 권장 (NIO.2)
public String readShipmentTextModern(Path path) throws IOException {
return Files.readString(path, StandardCharsets.UTF_8);
}
// Stream
public List<Shipment> readShipmentsStream(Path path) throws IOException {
try (Stream<String> lines = Files.lines(path, StandardCharsets.UTF_8)) {
return lines.skip(1).map(this::parse).toList();
}
}
}2.8 자기 점검 답변
FileReader 의 정의와 한계는?
답:
1. 정의:
- InputStreamReader 의 자식
- 파일 전용 Reader
- java.io 패키지
-
한계 (Java 10 이하):
- 인코딩 명시 불가
- 시스템 기본 사용
- Cross-platform 위험
-
Java 11+ 개선:
FileReader(File, Charset)추가- 안전한 사용 가능
-
실무 권장:
Files.newBufferedReader(path, UTF_8)가 더 좋음- NIO.2 통합
-
활용:
- 짧은 텍스트
- BufferedReader 와 결합
3️⃣ InputStreamReader 의 정의와 활용
3.1 InputStreamReader 의 정의
package java.io;
public class InputStreamReader extends Reader {
// 생성자
public InputStreamReader(InputStream in);
public InputStreamReader(InputStream in, String charsetName)
throws UnsupportedEncodingException;
public InputStreamReader(InputStream in, Charset cs);
public InputStreamReader(InputStream in, CharsetDecoder dec);
}핵심:
- Reader 의 직접 자식
- InputStream 을 Reader 로 변환 (Bridge)
- 인코딩 명시 가능
- Java 1.1 부터
3.2 기본 사용
// InputStream → Reader 변환
try (FileInputStream fis = new FileInputStream("file.txt");
InputStreamReader isr = new InputStreamReader(fis, StandardCharsets.UTF_8)) {
int c;
while ((c = isr.read()) != -1) {
System.out.print((char) c);
}
}
// 줄 단위 (BufferedReader 결합)
try (InputStreamReader isr = new InputStreamReader(
new FileInputStream("file.txt"), StandardCharsets.UTF_8);
BufferedReader br = new BufferedReader(isr)) {
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
}3.3 다양한 InputStream 활용
// 1. 파일
new InputStreamReader(new FileInputStream("file.txt"), UTF_8);
// 2. 표준 입력
new InputStreamReader(System.in, UTF_8);
// 3. URL (네트워크)
URL url = new URL("https://example.com");
new InputStreamReader(url.openStream(), UTF_8);
// 4. 메모리
byte[] data = "안녕".getBytes(UTF_8);
new InputStreamReader(new ByteArrayInputStream(data), UTF_8);
// 5. 소켓
new InputStreamReader(socket.getInputStream(), UTF_8);
// 모든 InputStream 을 Reader 로3.4 인코딩 명시의 4가지 방법
// 1. 인코딩 안 함 (위험)
new InputStreamReader(in);
// 시스템 기본 인코딩
// 2. 문자열 인코딩 이름
new InputStreamReader(in, "UTF-8");
// UnsupportedEncodingException 가능
// 3. Charset 객체 (권장)
new InputStreamReader(in, StandardCharsets.UTF_8);
// 컴파일 타임 검증
// 4. CharsetDecoder (고급)
CharsetDecoder decoder = StandardCharsets.UTF_8.newDecoder();
decoder.onMalformedInput(CodingErrorAction.REPLACE);
new InputStreamReader(in, decoder);
// 에러 처리 옵션3.5 인코딩 변환 활용
// 같은 InputStream 을 다른 인코딩으로
public void readMultipleEncodings(byte[] data) throws IOException {
// 데이터가 어떤 인코딩인지 모를 때
Charset[] candidates = {
StandardCharsets.UTF_8,
Charset.forName("MS949"),
Charset.forName("EUC-KR"),
StandardCharsets.ISO_8859_1
};
for (Charset cs : candidates) {
try (InputStreamReader isr = new InputStreamReader(
new ByteArrayInputStream(data), cs)) {
CharBuffer buffer = CharBuffer.allocate(1024);
isr.read(buffer);
System.out.println("As " + cs + ": " + buffer.flip());
}
}
}3.6 InputStreamReader 의 내부 동작
사용자 호출:
isr.read()
내부 동작:
1. InputStream 에서 N 바이트 읽음 (필요한 만큼)
- UTF-8 의 첫 바이트로 길이 판단
- 1바이트 (ASCII), 2/3/4 바이트 (다국어)
2. CharsetDecoder 가 디코딩
- 바이트 시퀀스 → char
3. char 반환
복잡한 처리를 추상화
사용자는 단순히 char 받음3.7 ILIC 의 활용
public class ShipmentEncodingReader {
// 1. 단일 인코딩
public String readUtf8(Path path) throws IOException {
try (InputStreamReader isr = new InputStreamReader(
new FileInputStream(path.toFile()), StandardCharsets.UTF_8);
BufferedReader br = new BufferedReader(isr)) {
return br.lines().collect(Collectors.joining("\n"));
}
}
// 2. 옛 데이터 (EUC-KR)
public String readEucKr(Path path) throws IOException {
try (InputStreamReader isr = new InputStreamReader(
new FileInputStream(path.toFile()), Charset.forName("EUC-KR"));
BufferedReader br = new BufferedReader(isr)) {
return br.lines().collect(Collectors.joining("\n"));
}
}
// 3. HTTP 응답 (Content-Type 기반)
public String readHttpResponse(URL url) throws IOException {
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
String contentType = conn.getContentType();
// "text/html; charset=UTF-8"
Charset charset = extractCharset(contentType);
try (InputStreamReader isr = new InputStreamReader(
conn.getInputStream(), charset);
BufferedReader br = new BufferedReader(isr)) {
return br.lines().collect(Collectors.joining("\n"));
}
}
private Charset extractCharset(String contentType) {
// "text/html; charset=UTF-8" → UTF-8
if (contentType != null && contentType.contains("charset=")) {
String charsetName = contentType.split("charset=")[1].trim();
return Charset.forName(charsetName);
}
return StandardCharsets.UTF_8; // 기본
}
}3.8 자기 점검 답변
InputStreamReader 의 정의와 활용은?
답:
1. 정의:
- Reader 의 직접 자식
- InputStream → Reader 변환
- Bridge 패턴
-
본질:
- 인코딩 명시 가능
- 다양한 InputStream 활용
- 파일, 네트워크, 메모리 등
-
인코딩 명시:
- String (UnsupportedEncodingException)
- Charset (권장)
- CharsetDecoder (고급)
-
활용:
- 다양한 InputStream
- BufferedReader 결합 권장
- HTTP 응답 (Content-Type)
4️⃣ FileReader vs InputStreamReader 비교
4.1 비교 표
| 항목 | FileReader | InputStreamReader |
|---|---|---|
| 정의 | InputStreamReader 의 자식 | Reader 의 직접 자식 |
| 입력 | 파일만 | 모든 InputStream |
| 인코딩 (Java 10-) | X | ✓ |
| 인코딩 (Java 11+) | ✓ | ✓ |
| 유연성 | ↓ | ↑↑ |
| 코드 길이 | 짧음 | 약간 길음 |
| 활용 | 단순 파일 | 다양 |
4.2 같은 작업의 두 방식
// FileReader (Java 11+)
try (FileReader fr = new FileReader("file.txt", StandardCharsets.UTF_8)) {
int c;
while ((c = fr.read()) != -1) {
System.out.print((char) c);
}
}
// InputStreamReader (Java 1.1+)
try (FileInputStream fis = new FileInputStream("file.txt");
InputStreamReader isr = new InputStreamReader(fis, StandardCharsets.UTF_8)) {
int c;
while ((c = isr.read()) != -1) {
System.out.print((char) c);
}
}
// 결과 동일
// 코드는 FileReader 가 조금 짧음
// InputStreamReader 가 더 유연 (네트워크 등도 OK)4.3 FileReader 의 내부
// FileReader 는 사실상 InputStreamReader + FileInputStream
// Java 11+ FileReader 구현 (대략)
public class FileReader extends InputStreamReader {
public FileReader(File file, Charset charset) throws IOException {
super(new FileInputStream(file), charset);
}
public FileReader(String fileName, Charset charset) throws IOException {
super(new FileInputStream(fileName), charset);
}
}
// 즉:
// FileReader = InputStreamReader + FileInputStream 의 편의 래퍼4.4 언제 어느 것을?
FileReader 권장:
✓ 파일만 처리
✓ Java 11+ 환경
✓ 짧은 코드 우선
✓ 인코딩 명시
InputStreamReader 권장:
✓ 파일 외에도 처리 (네트워크, 메모리 등)
✓ Java 10 이하 호환
✓ 다양한 InputStream
✓ 학습/이해 (Bridge 패턴)
가장 권장 (NIO.2):
✓ Files.newBufferedReader(path, UTF_8)
✓ 가장 간결
✓ Path 활용4.5 가장 권장 패턴
// 가장 권장 — Files.newBufferedReader
try (BufferedReader reader = Files.newBufferedReader(
Path.of("file.txt"), StandardCharsets.UTF_8)) {
String line;
while ((line = reader.readLine()) != null) {
process(line);
}
}
// 또는 Stream
try (Stream<String> lines = Files.lines(
Path.of("file.txt"), StandardCharsets.UTF_8)) {
lines.forEach(this::process);
}
// 또는 한 번에 (작은 파일)
String content = Files.readString(Path.of("file.txt"), StandardCharsets.UTF_8);4.6 변환 표
같은 효과의 표현:
Files.newBufferedReader(path, UTF_8)
≡ new BufferedReader(new InputStreamReader(new FileInputStream(path.toFile()), UTF_8))
≡ new BufferedReader(new FileReader(path.toFile(), UTF_8)) // Java 11+
내부 동작:
1. FileInputStream — 바이트 스트림
2. InputStreamReader — 인코딩 적용
3. BufferedReader — 버퍼링 + readLine4.7 ILIC 의 패턴 선택
public class ShipmentReader {
private final Charset charset = StandardCharsets.UTF_8;
// 1. 가장 권장 — NIO.2
public List<Shipment> readAllModern(Path path) throws IOException {
try (Stream<String> lines = Files.lines(path, charset)) {
return lines.skip(1).map(this::parse).toList();
}
}
// 2. Java 11+ FileReader (간결)
public List<Shipment> readAllFileReader(Path path) throws IOException {
try (BufferedReader br = new BufferedReader(
new FileReader(path.toFile(), charset))) {
return br.lines().skip(1).map(this::parse).toList();
}
}
// 3. InputStreamReader (전통)
public List<Shipment> readAllInputStreamReader(Path path) throws IOException {
try (BufferedReader br = new BufferedReader(
new InputStreamReader(
new FileInputStream(path.toFile()),
charset))) {
return br.lines().skip(1).map(this::parse).toList();
}
}
// 4. 네트워크 (InputStreamReader 만 가능)
public List<Shipment> readFromUrl(URL url) throws IOException {
try (BufferedReader br = new BufferedReader(
new InputStreamReader(url.openStream(), charset))) {
return br.lines().skip(1).map(this::parse).toList();
}
}
}4.8 자기 점검 답변
FileReader 와 InputStreamReader 의 선택?
답:
1. FileReader:
- 파일 전용
- 짧은 코드
- Java 11+ 부터 안전
-
InputStreamReader:
- 모든 InputStream
- 유연
- Bridge 패턴
-
차이:
- FileReader = InputStreamReader + FileInputStream 래퍼
-
선택:
- 파일만: FileReader (Java 11+)
- 다양: InputStreamReader
- 가장 권장: Files.newBufferedReader
-
실무:
- NIO.2 활용
- 인코딩 명시 (UTF-8)
- BufferedReader 결합
5️⃣ 인코딩 명시의 중요성
5.1 명시 안 하면
// ❌ 인코딩 없음
new InputStreamReader(is);
new FileReader("file.txt"); // Java 10 이하
// 시스템 기본 인코딩 사용
// - Windows 한국어: MS949
// - Linux: UTF-8
// - Mac: UTF-8
// 문제:
// - 환경 따라 다름
// - Cross-platform 위험
// - 디버깅 어려움5.2 시나리오 — 서버와 로컬
시나리오:
- 개발자 로컬: Mac (UTF-8)
- 운영 서버: Linux (UTF-8)
- 옛 윈도우 서버: Windows (MS949)
UTF-8 로 저장된 파일을 읽기:
new FileReader("data.txt"):
- Mac: UTF-8 → OK
- Linux: UTF-8 → OK
- Windows: MS949 로 해석 → 깨짐!
같은 코드, 다른 결과5.3 Java 18+ 의 변화
JEP 400 (Java 18+):
- 기본 인코딩 UTF-8 통일
- 모든 OS
영향:
- Java 18+ 에선 FileReader 가 UTF-8 기본
- Cross-platform 일관성
하지만:
- 명시적 인코딩이 여전히 권장
- 의도 명확
- 다른 JVM 버전 호환
- 다른 인코딩 필요 시 대비5.4 인코딩 명시의 효과
// ✓ 명시적
try (Reader r = new InputStreamReader(is, StandardCharsets.UTF_8)) {
// 안전:
// - 모든 OS
// - 모든 Java 버전
// - 의도 명확
}5.5 잘못된 인코딩의 결과
// UTF-8 파일을 EUC-KR 로 읽기
byte[] utf8 = "안녕".getBytes(StandardCharsets.UTF_8);
// [0xEC, 0x95, 0x88, 0xEB, 0x85, 0x95]
try (Reader r = new InputStreamReader(
new ByteArrayInputStream(utf8), Charset.forName("EUC-KR"))) {
int c;
while ((c = r.read()) != -1) {
System.out.print((char) c);
}
}
// 출력: 깨진 한자 또는 ?
// EUC-KR 의 0xEC95 가 어떤 한자에 매핑되든
// 정상 한글 아님5.6 인코딩 자동 감지 (한계)
// 인코딩 추정 라이브러리 활용
// 예: ICU4J, juniversalchardet
import org.mozilla.universalchardet.UniversalDetector;
public Charset detectCharset(byte[] data) throws IOException {
UniversalDetector detector = new UniversalDetector(null);
detector.handleData(data, 0, data.length);
detector.dataEnd();
String charsetName = detector.getDetectedCharset();
return charsetName != null
? Charset.forName(charsetName)
: StandardCharsets.UTF_8;
}
// 한계:
// - 100% 정확 X
// - 통계적 추정
// - 짧은 데이터 부정확
// - 명시적 인코딩이 더 안전5.7 BOM (Byte Order Mark)
// UTF-8 BOM: 0xEF 0xBB 0xBF
// UTF-16 BE BOM: 0xFE 0xFF
// UTF-16 LE BOM: 0xFF 0xFE
// 파일 첫 부분에 BOM 이 있으면 인코딩 추정 가능
// 자바 표준은 BOM 자동 처리 X
// BOMInputStream (Apache Commons IO) 활용
import org.apache.commons.io.input.BOMInputStream;
try (InputStream is = new FileInputStream("file.txt");
BOMInputStream bis = new BOMInputStream(is, false); // BOM 제거
InputStreamReader isr = new InputStreamReader(bis, StandardCharsets.UTF_8);
BufferedReader br = new BufferedReader(isr)) {
// BOM 자동 제거
String line;
while ((line = br.readLine()) != null) {
// BOM 없는 깨끗한 데이터
}
}5.8 ILIC 의 인코딩 관리
public class EncodingConstants {
public static final Charset DEFAULT = StandardCharsets.UTF_8;
public static final Charset LEGACY_KOREAN = Charset.forName("MS949");
public static final Charset LATIN = StandardCharsets.ISO_8859_1;
}
@Service
public class ShipmentEncodingService {
// 항상 명시적 인코딩
public String readFile(Path path) throws IOException {
return Files.readString(path, EncodingConstants.DEFAULT);
}
// 옛 시스템 데이터
public String readLegacy(Path path) throws IOException {
return Files.readString(path, EncodingConstants.LEGACY_KOREAN);
}
// 변환
public void convertEncoding(Path src, Path dest,
Charset srcCharset, Charset destCharset) throws IOException {
String content = Files.readString(src, srcCharset);
Files.writeString(dest, content, destCharset);
}
// HTTP 응답
public String fetchUrl(String url) throws IOException {
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder(URI.create(url)).build();
try {
HttpResponse<String> response = client.send(request,
BodyHandlers.ofString(EncodingConstants.DEFAULT));
return response.body();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new IOException(e);
}
}
}5.9 자기 점검 답변
인코딩 명시의 중요성은?
답:
1. 명시 안 하면:
- 시스템 기본 사용
- Windows MS949 vs Linux UTF-8
- Cross-platform 위험
-
Java 18+:
- UTF-8 기본화 (JEP 400)
- 하지만 여전히 명시 권장
-
잘못된 인코딩 결과:
- 한글 깨짐
- 데이터 손실
- 디버깅 어려움
-
권장:
- StandardCharsets.UTF_8 명시
- 일관된 인코딩
- 의도 명확
-
BOM:
- 파일 첫 부분 인코딩 표시
- Apache Commons IO 활용
6️⃣ BufferedReader 와의 결합
6.1 BufferedReader 의 정의
public class BufferedReader extends Reader {
public BufferedReader(Reader in);
public BufferedReader(Reader in, int sz);
// 핵심 메서드
public String readLine() throws IOException;
// 상속
public int read();
public int read(char[] cbuf, int off, int len);
// Java 8+
public Stream<String> lines();
}특징:
- Reader 의 자식 + Reader 받음 (Decorator)
- 내부 버퍼 (기본 8KB)
- readLine (한 줄씩)
- Stream API (lines)
6.2 결합 패턴
// 기본 결합
try (BufferedReader br = new BufferedReader(
new InputStreamReader(
new FileInputStream("file.txt"),
StandardCharsets.UTF_8))) {
// ...
}
// Java 11+ FileReader
try (BufferedReader br = new BufferedReader(
new FileReader("file.txt", StandardCharsets.UTF_8))) {
// ...
}
// NIO.2 (가장 권장)
try (BufferedReader br = Files.newBufferedReader(
Path.of("file.txt"), StandardCharsets.UTF_8)) {
// ...
}
// 모두 같은 효과6.3 readLine — 한 줄씩
// readLine 의 동작
public String readLine() throws IOException;
// 반환:
// - 한 줄 (\n, \r, \r\n 제외)
// - null (EOF)
// 사용
try (BufferedReader br = Files.newBufferedReader(path)) {
String line;
while ((line = br.readLine()) != null) {
process(line);
}
}
// readLine 의 구분자:
// \n (LF, Unix)
// \r (CR, Old Mac)
// \r\n (CRLF, Windows)
// 모두 처리, 결과에서 제외6.4 BufferedReader 의 버퍼링
일반 Reader (8KB 버퍼 없음):
read() → InputStreamReader → InputStream → OS
매 호출이 system call
BufferedReader (8KB 버퍼):
read() → BufferedReader 의 char[8192]
버퍼 비면 InputStreamReader 에서 채움
대부분 메모리 접근
효과:
- read 호출 빠름
- readLine 효율적6.5 Stream API (Java 8+)
// lines() 메서드
try (BufferedReader br = Files.newBufferedReader(path)) {
br.lines()
.filter(l -> !l.isBlank())
.map(String::trim)
.forEach(System.out::println);
}
// Files.lines (더 간단)
try (Stream<String> lines = Files.lines(path)) {
lines.filter(...)
.map(...)
.forEach(...);
}
// 차이:
// - BufferedReader.lines(): 자기가 만든 reader
// - Files.lines(): NIO.2 의 정적 메서드
// - 둘 다 try-with-resources 필수6.6 readLine vs read 비교
// 한 줄씩 — readLine
String line;
while ((line = br.readLine()) != null) {
process(line);
}
// 가독성 ↑
// 메모리: 한 줄 정도
// 한 문자씩 — read
int c;
while ((c = br.read()) != -1) {
process((char) c);
}
// 더 세밀한 제어
// 토큰 단위 파싱 등
// 청크 단위 — read(char[])
char[] buf = new char[1024];
int n;
while ((n = br.read(buf)) != -1) {
process(buf, 0, n); // ★ n 만큼만!
}
// 효율 ↑
// 마지막 함정 주의6.7 ILIC 의 BufferedReader 활용
public class ShipmentLogReader {
// 1. 한 줄씩 처리
public List<String> readLogLines(Path logFile) throws IOException {
List<String> lines = new ArrayList<>();
try (BufferedReader br = Files.newBufferedReader(logFile, StandardCharsets.UTF_8)) {
String line;
while ((line = br.readLine()) != null) {
lines.add(line);
}
}
return lines;
}
// 2. Stream + 필터링
public List<String> findErrorLogs(Path logFile) throws IOException {
try (Stream<String> lines = Files.lines(logFile, StandardCharsets.UTF_8)) {
return lines
.filter(l -> l.contains("ERROR"))
.toList();
}
}
// 3. 그룹핑
public Map<String, Long> countByLevel(Path logFile) throws IOException {
try (Stream<String> lines = Files.lines(logFile, StandardCharsets.UTF_8)) {
return lines
.map(this::extractLevel)
.collect(Collectors.groupingBy(
Function.identity(),
Collectors.counting()));
}
}
// 4. 대용량 처리
public long countLines(Path logFile) throws IOException {
try (Stream<String> lines = Files.lines(logFile, StandardCharsets.UTF_8)) {
return lines.count();
}
}
private String extractLevel(String line) {
// "2026-05-19 [INFO] message"
int start = line.indexOf('[');
int end = line.indexOf(']');
return (start >= 0 && end > start) ? line.substring(start + 1, end) : "UNKNOWN";
}
}6.8 자기 점검 답변
BufferedReader 의 효과는?
답:
1. 정의:
- Reader + 버퍼링
- Decorator 패턴
- 8KB 기본 버퍼
-
핵심 메서드:
- readLine: 한 줄씩
- lines: Stream
- read: 효율적 (버퍼)
-
결합:
- BufferedReader + InputStreamReader + FileInputStream
- 또는 BufferedReader + FileReader (Java 11+)
- 또는 Files.newBufferedReader (NIO.2)
-
효과:
- readLine 의 편의
- Stream API
- 효율적 read
-
권장:
- Files.newBufferedReader 가 가장 간결
7️⃣ char 의 한계 (Supplementary 문자)
7.1 char 의 본질
Java 의 char:
- 16비트 (2바이트)
- 0 ~ 65535
- UTF-16 의 한 단위 (code unit)
표현 가능 범위:
- BMP (Basic Multilingual Plane): 0x0000 ~ 0xFFFF
- 65,536 코드 포인트7.2 BMP 와 Supplementary Plane
유니코드의 분류:
BMP (Basic Multilingual Plane):
- 0x0000 ~ 0xFFFF
- 대부분의 문자
- 영어, 한글, 한자 (기본), 일본어, 그리스어 등
- char 1개로 표현
Supplementary Planes:
- 0x10000 ~ 0x10FFFF
- 이모지 😀
- 고대 문자
- 일부 한자 (확장)
- char 2개로 표현 (Surrogate Pair)7.3 Surrogate Pair
Surrogate Pair:
Supplementary 문자 (BMP 밖) 을
char 2개로 표현하는 방법.
High Surrogate: 0xD800 ~ 0xDBFF
Low Surrogate: 0xDC00 ~ 0xDFFF
예: 😀 (U+1F600, GRINNING FACE)
UTF-16: 0xD83D 0xDE00 (2 char)
"😀".length() == 2 // char 길이
"😀".codePointCount(0, 2) == 1 // 코드 포인트 수7.4 Reader.read() 의 한계
// Reader.read() 는 1 char 반환
// Supplementary 문자는 두 번 read 필요
try (Reader r = new InputStreamReader(
new ByteArrayInputStream("😀".getBytes(UTF_8)),
UTF_8)) {
int c1 = r.read(); // 0xD83D (High Surrogate)
int c2 = r.read(); // 0xDE00 (Low Surrogate)
int c3 = r.read(); // -1 (EOF)
// 단일 char 로는 불완전
String s = "" + (char) c1 + (char) c2;
// "😀" (정상)
}7.5 codePoint 활용
// Code Point 단위 처리
String s = "Hello 😀 World";
// 잘못 — char 기반
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
System.out.println(c);
// 😀 가 두 char 로 나옴 (깨진 표시)
}
// 올바름 — Code Point
s.codePoints().forEach(cp -> {
String character = new String(Character.toChars(cp));
System.out.println(character);
// 😀 가 한 문자
});
// 또는 iterator
for (int i = 0; i < s.length(); ) {
int cp = s.codePointAt(i);
String character = new String(Character.toChars(cp));
System.out.println(character);
i += Character.charCount(cp); // 1 또는 2
}7.6 BufferedReader 와 이모지
// 이모지가 있는 파일
String text = "Hello 😀\n안녕 🌍";
Files.writeString(Path.of("emoji.txt"), text, StandardCharsets.UTF_8);
// 읽기 — 정상
try (BufferedReader br = Files.newBufferedReader(
Path.of("emoji.txt"), StandardCharsets.UTF_8)) {
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
// 이모지 포함 정상 출력
}
}
// BufferedReader.readLine 은 String 반환
// String 은 Surrogate Pair 안전하게 처리
// 단, length(), charAt() 사용 시 주의7.7 일반 한글 vs 한자 확장
일반 한글 (BMP):
'안' = U+C548 (49992)
char 1개
한자 확장 (Supplementary):
'𠮷' (U+20BB7) — 일부 한자
char 2개 (Surrogate Pair)
영향:
- 일반 한글: char 안전
- 확장 한자, 이모지: Surrogate Pair 필요
- Code Point 기반 처리 권장7.8 ILIC 의 활용 (확장 문자 처리)
public class TextProcessor {
// 정확한 문자 수 계산
public int countCharacters(String text) {
return text.codePointCount(0, text.length());
// Surrogate Pair 를 1로 계산
}
// 안전한 길이 자르기
public String truncate(String text, int maxChars) {
if (text.codePointCount(0, text.length()) <= maxChars) {
return text;
}
StringBuilder sb = new StringBuilder();
int count = 0;
int i = 0;
while (i < text.length() && count < maxChars) {
int cp = text.codePointAt(i);
sb.appendCodePoint(cp);
i += Character.charCount(cp);
count++;
}
return sb.toString();
}
// 이모지 제거 (예시)
public String removeEmoji(String text) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < text.length(); ) {
int cp = text.codePointAt(i);
if (!isEmoji(cp)) {
sb.appendCodePoint(cp);
}
i += Character.charCount(cp);
}
return sb.toString();
}
private boolean isEmoji(int cp) {
// 이모지 범위 (대략)
return cp >= 0x1F600 && cp <= 0x1F64F;
}
}7.9 자기 점검 답변
char 의 한계와 Supplementary 문자는?
답:
1. char 의 크기:
- 16비트 (0~65535)
- UTF-16 의 한 단위
- BMP 만 표현
-
BMP:
- 0x0000 ~ 0xFFFF
- 대부분의 일반 문자
- 영어, 일반 한글 OK
-
Supplementary:
- 0x10000 ~ 0x10FFFF
- 이모지, 확장 한자
- char 2개 (Surrogate Pair)
-
처리:
codePoint기반Character.charCountcodePoints().forEach
-
영향:
- 일반 한글: 안전
- 이모지/확장: 주의
8️⃣ Java 11+ 의 개선과 실무 패턴
8.1 Java 11+ 의 개선
Java 11 의 FileReader 개선:
이전 (Java 10 이하):
new FileReader("file.txt") // 시스템 기본 인코딩
Java 11+:
new FileReader("file.txt") // 시스템 기본 (호환)
new FileReader("file.txt", StandardCharsets.UTF_8) // 인코딩 명시 ✓
새 생성자:
FileReader(String, Charset)
FileReader(File, Charset)
이제 FileReader 도 안전하게 사용 가능8.2 Java 18+ 의 변화
JEP 400 (Java 18+):
기본 인코딩 UTF-8 통일.
영향:
- new FileReader("file.txt") 가 UTF-8 (모든 OS)
- new InputStreamReader(is) 가 UTF-8
- 시스템 기본 의존 사라짐
호환:
- -Dfile.encoding=COMPAT (옛 동작)
- 명시적 인코딩 여전히 권장8.3 실무 권장 패턴 종합
// 1. 가장 권장 — Files.newBufferedReader
<try (BufferedReader reader = Files.newBufferedReader(
Path.of("file.txt"), StandardCharsets.UTF_8)) {
String line;
while ((line = reader.readLine()) != null) {
process(line);
}
}
// 2. Stream 처리
try (Stream<String> lines = Files.lines(
Path.of("file.txt"), StandardCharsets.UTF_8)) {
lines.filter(...)
.map(...)
.forEach(...);
}
// 3. 한 번에 읽기 (작은 파일)
String content = Files.readString(
Path.of("file.txt"), StandardCharsets.UTF_8);
List<String> allLines = Files.readAllLines(
Path.of("file.txt"), StandardCharsets.UTF_8);
// 4. 다양한 InputStream
try (Reader r = new InputStreamReader(
url.openStream(), StandardCharsets.UTF_8);
BufferedReader br = new BufferedReader(r)) {
// URL 응답 처리
}
// 5. 표준 입력
try (BufferedReader br = new BufferedReader(
new InputStreamReader(System.in, StandardCharsets.UTF_8))) {
String line = br.readLine();
}8.4 인코딩 상수의 활용
// Constants 클래스
public class IoConstants {
public static final Charset UTF8 = StandardCharsets.UTF_8;
public static final Charset MS949 = Charset.forName("MS949");
public static final Charset EUC_KR = Charset.forName("EUC-KR");
public static final int BUFFER_SIZE = 8192;
}
// 활용
try (BufferedReader br = Files.newBufferedReader(path, IoConstants.UTF8)) {
// ...
}
// 일관성:
// - 모든 코드에서 같은 인코딩
// - 변경 용이
// - 의도 명확8.5 ILIC 의 권장 패턴
@Service
public class ShipmentTextService {
private static final Charset CHARSET = StandardCharsets.UTF_8;
// 1. CSV 읽기
public List<Shipment> importCsv(Path path) throws IOException {
try (Stream<String> lines = Files.lines(path, CHARSET)) {
return lines
.skip(1) // 헤더
.map(this::parseShipment)
.toList();
}
}
// 2. 큰 파일 청크 처리
public void processLargeFile(Path path, LineProcessor processor) throws IOException {
try (BufferedReader br = Files.newBufferedReader(path, CHARSET)) {
String line;
long lineNum = 0;
while ((line = br.readLine()) != null) {
processor.process(lineNum++, line);
}
}
}
// 3. 한글 검증
public boolean isValidKorean(Path path) throws IOException {
try (BufferedReader br = Files.newBufferedReader(path, CHARSET)) {
String line;
while ((line = br.readLine()) != null) {
if (containsCorruptedChars(line)) {
return false;
}
}
return true;
}
}
// 4. HTTP 응답 처리
public String fetchShipmentData(String url) throws IOException {
HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
// Content-Type 의 charset 활용
String contentType = conn.getContentType();
Charset charset = extractCharset(contentType, CHARSET);
try (BufferedReader br = new BufferedReader(
new InputStreamReader(conn.getInputStream(), charset))) {
return br.lines().collect(Collectors.joining("\n"));
}
}
private boolean containsCorruptedChars(String line) {
// U+FFFD (replacement character) 검사
return line.contains("\uFFFD");
}
private Charset extractCharset(String contentType, Charset defaultCharset) {
if (contentType != null && contentType.contains("charset=")) {
try {
return Charset.forName(contentType.split("charset=")[1].trim());
} catch (Exception e) {
// 무시
}
}
return defaultCharset;
}
@FunctionalInterface
interface LineProcessor {
void process(long lineNum, String line);
}
}8.6 자주 발생하는 인코딩 버그
실무 인코딩 버그 5가지:
1. CSV Excel 에서 한글 깨짐
- 원인: Excel 의 BOM 요구
- 해결: UTF-8 BOM 추가
2. HTTP 응답 한글 깨짐
- 원인: Content-Type charset 누락
- 해결: 명시 또는 기본 UTF-8
3. DB 조회 한글 깨짐
- 원인: DB 인코딩 ↔ 클라이언트 인코딩 불일치
- 해결: 모두 UTF-8
4. 파일 이름 한글 깨짐
- 원인: 파일 시스템 인코딩
- 해결: -Dfile.encoding=UTF-8
5. 컴파일러 인코딩
- 원인: 소스 파일 인코딩
- 해결: -encoding UTF-8 (javac)8.7 디버깅 팁
// 인코딩 확인
String defaultCharset = Charset.defaultCharset().name();
String fileEncoding = System.getProperty("file.encoding");
String consoleEncoding = System.getProperty("console.encoding");
System.out.println("Default: " + defaultCharset);
System.out.println("File: " + fileEncoding);
System.out.println("Console: " + consoleEncoding);
// 바이트 hex 출력
byte[] bytes = "안녕".getBytes(StandardCharsets.UTF_8);
for (byte b : bytes) {
System.out.printf("%02X ", b);
}
// EC 95 88 EB 85 95
// 다양한 인코딩으로 해석
byte[] data = ...;
for (Charset cs : List.of(UTF_8, UTF_16, Charset.forName("MS949"), Charset.forName("EUC-KR"))) {
System.out.println(cs + ": " + new String(data, cs));
}8.8 자기 점검 답변
Java 11+ 의 개선과 권장 패턴은?
답:
1. Java 11+ 개선:
FileReader(File, Charset)추가- 인코딩 명시 가능
-
Java 18+ 변화:
- JEP 400: UTF-8 기본
- 모든 OS 통일
-
가장 권장:
Files.newBufferedReader(path, UTF_8)- NIO.2 활용
- Stream API
-
명시적 인코딩:
- StandardCharsets.UTF_8
- 의도 명확
- 호환성
-
실무 5가지 버그:
- CSV Excel, HTTP, DB, 파일명, 컴파일러
9️⃣ 면접 + 자기 점검
9.1 면접 단골 질문 매핑
| Q | 핵심 답변 |
|---|---|
| Reader 정의? | 문자 단위, 인코딩 인식 |
| Reader vs InputStream? | char vs byte, 인코딩 |
| FileReader 한계? | Java 10 이하 인코딩 명시 X |
| InputStreamReader 역할? | Bridge (InputStream → Reader) |
| 인코딩 명시 안 하면? | 시스템 기본, Cross-platform 위험 |
| BufferedReader 효과? | 버퍼링 + readLine |
| readLine 의 줄 구분? | \n, \r, \r\n |
| Reader.read() 반환? | 0~65535 또는 -1 |
| char 16비트? | UTF-16 한 단위 |
| Supplementary 문자? | 이모지, char 2개 (Surrogate) |
| Java 18+ 변화? | UTF-8 기본 |
| 가장 권장? | Files.newBufferedReader(path, UTF_8) |
9.2 자기 점검 체크리스트
Reader
- Reader 의 정의
- InputStream 과 차이
- char vs byte
- 인코딩 인식
FileReader
- 정의 (InputStreamReader 자식)
- Java 10 이하 한계
- Java 11+ 개선
- 시스템 인코딩 위험
InputStreamReader
- 정의 (Bridge)
- 인코딩 명시 4가지
- 다양한 InputStream
- BufferedReader 결합
BufferedReader
- 8KB 버퍼
- readLine
- lines() (Stream)
- 줄 구분자 처리
인코딩
- StandardCharsets.UTF_8
- Java 18+ 기본
- 명시적 권장
- BOM 처리
char 한계
- 16비트 한도
- BMP vs Supplementary
- Surrogate Pair
- Code Point 처리
실무
- Files.newBufferedReader 권장
- Stream API 활용
- 인코딩 상수
- 흔한 버그 5가지
9.3 추가 심화 질문
Q1: Reader 가 char 인데 한자 (확장) 처리?
답:
- 일반 한자: BMP, char 1개 OK
- 확장 한자 (Supplementary): char 2개
- BufferedReader.readLine 은 String 반환
- String 은 Surrogate Pair 안전
- length() 는 char 단위 (확장은 2)
- codePointCount() 가 진짜 문자 수
Q2: 잘못된 UTF-8 바이트 만나면?
답:
// 기본 동작
Charset.forName("UTF-8");
// 잘못된 시퀀스 → U+FFFD (replacement character) 로 치환
// 엄격하게
CharsetDecoder decoder = StandardCharsets.UTF_8.newDecoder();
decoder.onMalformedInput(CodingErrorAction.REPORT); // 예외
decoder.onUnmappableCharacter(CodingErrorAction.REPORT);
try (Reader r = new InputStreamReader(is, decoder)) {
// MalformedInputException
}Q3: 매우 큰 파일을 readLine?
답:
- BufferedReader.readLine 은 한 줄을 String 으로
- 줄이 매우 길면 메모리 부담
- 1줄에 1GB 같은 극단적 경우 OOM
- 해결: 청크 단위 read(char[])
Q4: read(char[]) 의 마지막 함정?
답:
char[] buf = new char[1024];
int n = br.read(buf);
// n < buf.length 가능
// ❌ for-each
for (char c : buf) { ... }
// ✓ n 까지만
for (int i = 0; i < n; i++) { ... }
// InputStream 의 read(byte[]) 와 동일한 함정Q5: Reader 와 NIO 의 Channel?
답:
- Reader: java.io, char 단위
- Channel: java.nio, ByteBuffer 단위
- 변환:
- Channels.newReader(channel, charset)
- Channels.newChannel(reader)
- 큰 파일: Channel + DirectBuffer 가 효율
🎯 핵심 요약 — 3줄 정리
1. Reader vs InputStream
- Reader: char (문자), 인코딩 인식
- InputStream: byte, raw
- 한글은 Reader 필수
2. FileReader vs InputStreamReader
- FileReader: 파일 전용 (Java 11+ 안전)
- InputStreamReader: 모든 InputStream (Bridge)
- 가장 권장: Files.newBufferedReader
3. 권장 패턴
- 항상 인코딩 명시 (StandardCharsets.UTF_8)
- BufferedReader 결합
- Stream API (lines)
- NIO.2 의 Files
📚 다음으로...
Unit 8.6 — FileWriter (한글 쓰기)
이번 Unit에서 한글 읽기를 봤다면, 다음은 한글 쓰기 + Phase 8 완주.
- FileWriter 의 정의
- OutputStreamWriter 와의 비교
- 다양한 write 메서드
- BufferedWriter 결합
- Phase 8 완주
Phase 8 진행 상황
🚀 Phase 8 — Stream 실전
✅ 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 8 완주3주차 누적 진행
✅ Phase 1 ~ 7 완주 (31 Unit)
🚀 Phase 8 — Stream 실전 (5/6 진행)
총: 36/43 Unit (약 84%)
Software Developer