Unit 9.3 — DataInputStream / DataOutputStream
F-LAB JAVA · 3주차 · Phase 9 · I/O 강화
📌 학습 목표
이 Unit을 끝내면 다음을 답할 수 있어야 한다.
- DataInputStream / DataOutputStream 의 정의와 활용 시점은?
- 기본 타입 메서드 (readInt, readLong, readDouble, readUTF 등) 의 동작은?
- 바이너리 형식 vs 텍스트 형식 의 차이는?
- 엔디언 (Big-Endian) 과 자바의 선택은?
- readUTF / writeUTF 의 특별한 형식 (Modified UTF-8) 은?
- readFully 가 read 와 어떻게 다른가?
- DataInput / DataOutput 인터페이스 의 역할은?
- 타입별 바이트 크기 (int 4, long 8, double 8 등) 는?
- 직렬화와의 관계 는? (다음 Unit 의 토대)
🎯 핵심 한 문장
DataInputStream과DataOutputStream은 자바의 기본 타입 (int, long, float, double, boolean, char, String) 을 바이너리 형식 으로 읽고 쓰는 Decorator 스트림이다.
writeInt(42)는 텍스트 "42" (2바이트) 가 아니라 바이너리 4바이트 (0x00 0x00 0x00 0x2A, Big-Endian) 로 저장 — 파싱 불필요, 빠름, 정확.
readUTF / writeUTF는 Modified UTF-8 형식 (앞 2바이트 길이 + UTF-8 데이터) 으로 문자열 안전 저장.
readFully는 정확히 요청한 바이트를 채울 때까지 읽으며, 부족하면EOFException— 헤더 등 정확한 크기 처리에 필수.
다음 Unit 의 객체 직렬화 (ObjectInputStream) 가 내부적으로 DataInputStream 의 메커니즘 활용 — 직렬화의 토대.
비유 — 우편 보내기
텍스트 형식 (PrintStream):
편지에 "42" (두 글자) 쓰기
- 사람이 읽기 좋음
- 파싱 (Integer.parseInt) 필요
- 가변 크기 ("42" 2바이트, "12345" 5바이트)
바이너리 형식 (DataOutputStream):
편지에 정수 42 자체 (4바이트) 쓰기
- 기계가 빠르게 처리
- 파싱 불필요
- 고정 크기 (모든 int = 4바이트)
readUTF:
"안녕" → [길이 (2바이트)][UTF-8 6바이트]
- 길이 정보 포함
- 안전한 String 저장→ DataInput/Output = 자바 타입 ↔ 바이너리.
🧭 9개 섹션 로드맵
1. DataInputStream / DataOutputStream 의 정의
2. 기본 타입 메서드 종합
3. 바이너리 vs 텍스트 형식
4. 엔디언 (Big-Endian)
5. readUTF / writeUTF 의 Modified UTF-8
6. readFully — 정확한 읽기
7. DataInput / DataOutput 인터페이스
8. 실무 활용과 함정
9. 면접 + 자기 점검1️⃣ DataInputStream / DataOutputStream 의 정의
1.1 DataInputStream 의 정의
package java.io;
public class DataInputStream extends FilterInputStream implements DataInput {
public DataInputStream(InputStream in);
// DataInput 인터페이스 구현
public boolean readBoolean() throws IOException;
public byte readByte() throws IOException;
public char readChar() throws IOException;
public short readShort() throws IOException;
public int readInt() throws IOException;
public long readLong() throws IOException;
public float readFloat() throws IOException;
public double readDouble() throws IOException;
public String readUTF() throws IOException;
public void readFully(byte[] b) throws IOException;
public void readFully(byte[] b, int off, int len) throws IOException;
public int skipBytes(int n) throws IOException;
public String readLine() throws IOException; // deprecated
// 추가
public int read(byte[] b, int off, int len);
public int read();
}핵심:
- FilterInputStream 의 자식 (Decorator)
- DataInput 인터페이스 구현
- 기본 타입 메서드 제공
- Java 1.0 부터
1.2 DataOutputStream 의 정의
package java.io;
public class DataOutputStream extends FilterOutputStream implements DataOutput {
protected int written; // 쓴 바이트 수
public DataOutputStream(OutputStream out);
// DataOutput 인터페이스 구현
public void writeBoolean(boolean v) throws IOException;
public void writeByte(int v) throws IOException;
public void writeChar(int v) throws IOException;
public void writeShort(int v) throws IOException;
public void writeInt(int v) throws IOException;
public void writeLong(long v) throws IOException;
public void writeFloat(float v) throws IOException;
public void writeDouble(double v) throws IOException;
public void writeUTF(String str) throws IOException;
public void writeBytes(String s) throws IOException;
public void writeChars(String s) throws IOException;
public final int size() { return written; }
}핵심:
- FilterOutputStream 의 자식
- DataOutput 인터페이스 구현
- 매 write 마다 written 증가
- Java 1.0 부터
1.3 위치 (계층)
InputStream
├── FileInputStream
├── FilterInputStream
│ ├── BufferedInputStream
│ ├── DataInputStream ← 여기
│ └── PushbackInputStream
└── ...
OutputStream
├── FileOutputStream
├── FilterOutputStream
│ ├── BufferedOutputStream
│ ├── DataOutputStream ← 여기
│ └── PrintStream
└── ...1.4 기본 사용
// 쓰기
try (DataOutputStream dos = new DataOutputStream(
new FileOutputStream("data.bin"))) {
dos.writeInt(42);
dos.writeLong(1234567890L);
dos.writeDouble(3.14);
dos.writeBoolean(true);
dos.writeUTF("Hello");
}
// 읽기 (같은 순서로!)
try (DataInputStream dis = new DataInputStream(
new FileInputStream("data.bin"))) {
int i = dis.readInt(); // 42
long l = dis.readLong(); // 1234567890
double d = dis.readDouble(); // 3.14
boolean b = dis.readBoolean(); // true
String s = dis.readUTF(); // "Hello"
}1.5 Decorator 의 활용
// BufferedStream 과 결합 (효율)
try (DataOutputStream dos = new DataOutputStream(
new BufferedOutputStream(
new FileOutputStream("data.bin")))) {
// BufferedOutputStream 으로 system call 절감
// DataOutputStream 으로 타입 변환
dos.writeInt(42);
}
// 읽기도 동일
try (DataInputStream dis = new DataInputStream(
new BufferedInputStream(
new FileInputStream("data.bin")))) {
int i = dis.readInt();
}1.6 ILIC 활용
public class ShipmentBinaryStorage {
// 1. 바이너리 저장
public void save(Path path, Shipment s) throws IOException {
try (DataOutputStream dos = new DataOutputStream(
new BufferedOutputStream(
new FileOutputStream(path.toFile())))) {
dos.writeLong(s.getId());
dos.writeUTF(s.getBlNo());
dos.writeDouble(s.getWeight().doubleValue());
dos.writeLong(s.getCreatedAt().toEpochMilli());
dos.writeBoolean(s.isActive());
}
}
// 2. 바이너리 로드
public Shipment load(Path path) throws IOException {
try (DataInputStream dis = new DataInputStream(
new BufferedInputStream(
new FileInputStream(path.toFile())))) {
return Shipment.builder()
.id(dis.readLong())
.blNo(dis.readUTF())
.weight(BigDecimal.valueOf(dis.readDouble()))
.createdAt(Instant.ofEpochMilli(dis.readLong()))
.active(dis.readBoolean())
.build();
}
}
}1.7 자기 점검 답변
DataInputStream / DataOutputStream 의 정의는?
답:
1. 정의:
- FilterInputStream/OutputStream 자식
- DataInput/DataOutput 인터페이스 구현
- Decorator
-
목적:
- 자바 기본 타입 ↔ 바이너리
- readInt, writeLong 등
- Modified UTF-8
-
활용:
- BufferedStream 과 결합 권장
- 같은 순서로 read/write
-
위치:
- java.io
- Java 1.0+
2️⃣ 기본 타입 메서드 종합
2.1 모든 타입의 크기
| 타입 | 크기 (바이트) | read 메서드 | write 메서드 |
|---|---|---|---|
| boolean | 1 | readBoolean | writeBoolean |
| byte | 1 | readByte | writeByte |
| char | 2 | readChar | writeChar |
| short | 2 | readShort | writeShort |
| int | 4 | readInt | writeInt |
| long | 8 | readLong | writeLong |
| float | 4 | readFloat | writeFloat |
| double | 8 | readDouble | writeDouble |
| String | 가변 | readUTF | writeUTF |
2.2 boolean (1바이트)
// write
dos.writeBoolean(true); // 0x01
dos.writeBoolean(false); // 0x00
// read
boolean b = dis.readBoolean();
// 0x01 → true
// 0x00 → false
// 그 외 → 0이 아니면 true2.3 정수 타입
// byte (1바이트, signed -128 ~ 127)
dos.writeByte(65); // 0x41
byte b = dis.readByte(); // 65
// 또는 readByte 의 반환은 int (정밀)
// 실제로는 byte 처리
// short (2바이트, -32768 ~ 32767)
dos.writeShort(1000); // 0x03 0xE8
short s = dis.readShort(); // 1000
// int (4바이트, -2,147,483,648 ~ 2,147,483,647)
dos.writeInt(42); // 0x00 0x00 0x00 0x2A
int i = dis.readInt(); // 42
// long (8바이트, ±9 × 10^18)
dos.writeLong(1234567890L);
long l = dis.readLong();2.4 부동 소수점
// float (4바이트, IEEE 754 single precision)
dos.writeFloat(3.14f);
float f = dis.readFloat();
// double (8바이트, IEEE 754 double precision)
dos.writeDouble(3.14);
double d = dis.readDouble();
// 정확도 차이:
// float: 약 7자리
// double: 약 15자리2.5 문자
// char (2바이트, UTF-16)
dos.writeChar('A'); // 0x00 0x41
dos.writeChar('안'); // 0xC5 0x48
char c = dis.readChar();2.6 String — 두 가지 방식
// 방법 1: writeUTF (권장)
dos.writeUTF("안녕");
// [길이 6바이트][UTF-8 6바이트] = 총 8바이트
String s = dis.readUTF(); // "안녕"
// 방법 2: writeChars (UTF-16, 비효율)
dos.writeChars("안녕");
// 각 char 2바이트 = 4바이트
// 단, 길이 정보 없음
// readChars 도 없음 → 사용 X
// 방법 3: writeBytes (Latin-1, 정보 손실)
dos.writeBytes("Hello");
// 각 char 의 하위 8비트만
// 한글은 손실
// 사용 X2.7 크기 계산
// 정확한 바이트 수 예측
public class Shipment {
long id; // 8
String blNo; // 가변 (writeUTF: 2 + UTF-8 길이)
double weight; // 8
boolean active; // 1
}
// 저장 시 약:
// 8 + (2 + blNo의 UTF-8 길이) + 8 + 1 = 19 + blNo 길이
// 또는 size() 메서드로 확인
DataOutputStream dos = new DataOutputStream(...);
dos.writeLong(id);
dos.writeUTF(blNo);
int written = dos.size(); // 지금까지 쓴 바이트2.8 ILIC 활용
public class ShipmentBinaryFormat {
// 1. 모든 타입 활용
public void save(Path path, Shipment s) throws IOException {
try (DataOutputStream dos = new DataOutputStream(
new BufferedOutputStream(
new FileOutputStream(path.toFile())))) {
// 기본 정보
dos.writeLong(s.getId());
dos.writeUTF(s.getBlNo());
dos.writeUTF(s.getConsignee());
// 숫자
dos.writeDouble(s.getWeight().doubleValue());
dos.writeInt(s.getQuantity());
// 시간
dos.writeLong(s.getCreatedAt().toEpochMilli());
// 상태
dos.writeBoolean(s.isActive());
dos.writeByte(s.getStatus().ordinal());
// 위치
dos.writeFloat(s.getLatitude());
dos.writeFloat(s.getLongitude());
}
}
// 2. 정확한 크기 계산
public int estimateSize(Shipment s) throws IOException {
try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
DataOutputStream dos = new DataOutputStream(baos)) {
save(dos, s);
return dos.size();
}
}
}2.9 자기 점검 답변
기본 타입의 크기와 메서드는?
답:
1. 고정 크기:
- boolean, byte: 1
- char, short: 2
- int, float: 4
- long, double: 8
-
메서드:
- readXxx / writeXxx
- String 은 readUTF / writeUTF
-
String 방식:
- writeUTF: 길이 + Modified UTF-8 (권장)
- writeChars: UTF-16 (길이 X, 비권장)
- writeBytes: Latin-1 (손실, 비권장)
-
size() 메서드:
- DataOutputStream 에서
- 쓴 바이트 수
3️⃣ 바이너리 vs 텍스트 형식
3.1 두 형식의 차이
텍스트 형식:
정수 42 → "42" (2바이트 문자)
- 사람이 읽기 OK
- 파싱 필요 (Integer.parseInt)
- 가변 크기
- 큰 숫자 = 더 큼
바이너리 형식:
정수 42 → 0x00 0x00 0x00 0x2A (4바이트)
- 기계 처리 빠름
- 파싱 X
- 고정 크기
- 모든 int = 4바이트3.2 크기 비교
정수 42:
텍스트: 2바이트 ("42")
바이너리: 4바이트 (int)
텍스트 승
정수 1234567890:
텍스트: 10바이트 ("1234567890")
바이너리: 4바이트
바이너리 승
double 3.14159265:
텍스트: 10바이트 ("3.14159265")
바이너리: 8바이트
바이너리 승
긴 텍스트 "Hello, World!":
텍스트: 13바이트
바이너리 (writeUTF): 15바이트 (길이 2 + 13)
텍스트 약간 승
결론:
- 작은 숫자: 텍스트 작음
- 큰 숫자, double: 바이너리 작음
- 일관성: 바이너리 권장3.3 처리 속도 비교
// 텍스트 형식
try (BufferedWriter bw = Files.newBufferedWriter(path, UTF_8)) {
for (int i = 0; i < 1_000_000; i++) {
bw.write(String.valueOf(i));
bw.newLine();
}
}
// 매 i 마다:
// 1. Integer.toString (String 생성, GC)
// 2. write (인코딩 적용)
// 느림
// 바이너리 형식
try (DataOutputStream dos = new DataOutputStream(
new BufferedOutputStream(
new FileOutputStream(path.toFile())))) {
for (int i = 0; i < 1_000_000; i++) {
dos.writeInt(i);
}
}
// 매 i 마다:
// 4바이트 직접 쓰기
// 매우 빠름
// 결과 (대략):
// 텍스트: 5초
// 바이너리: 0.5초
// 약 10배 빠름3.4 가독성 차이
텍스트 파일 (열어볼 수 있음):
42
1234567890
3.14
안녕
바이너리 파일 (불가):
hex dump:
00 00 00 2A 00 00 00 00 49 96 02 D2 40 09 1E B8 51 EB 85 1F 00 06 EC 95 88 EB 85 95
- 사람이 읽기 어려움
- 전용 뷰어 필요
- 디버깅 어려움3.5 호환성
텍스트 형식:
- 모든 도구 (vi, cat, less)
- 어디서나
- 인코딩 주의
바이너리 형식:
- 전용 코드 필요
- 형식 정확히 알아야
- 끝없는 byte 의 의미 정의
- 버전 관리 어려움3.6 선택 가이드
텍스트 권장:
✓ 사람이 읽음
✓ 다양한 도구 사용
✓ 디버깅 우선
✓ 작은 데이터
✓ 로그, 설정
바이너리 권장:
✓ 성능 우선
✓ 큰 데이터
✓ 정확한 크기 (네트워크 프로토콜)
✓ 정밀한 부동소수점
✓ 인터널 (사람이 안 보는)3.7 하이브리드 — JSON
JSON:
- 텍스트 기반 (가독성)
- 구조화 (객체, 배열)
- 표준 (모든 언어)
- 파싱 라이브러리 풍부
장점:
- 텍스트 + 구조화
- 가독성 + 처리 편의
단점:
- 바이너리보다 큼
- 파싱 비용
비교:
텍스트: "42"
JSON: {"value": 42}
바이너리: 0x00000002A
JSON 이 일반적 권장
바이너리는 특수 경우만3.8 자기 점검 답변
바이너리 vs 텍스트 형식의 차이는?
답:
1. 크기:
- 작은 숫자: 텍스트 작음
- 큰 숫자/double: 바이너리 작음
-
속도:
- 바이너리 약 10배 빠름
- 파싱 X
-
가독성:
- 텍스트: 사람 OK
- 바이너리: 도구 필요
-
선택:
- 사람이 읽음: 텍스트
- 성능 우선: 바이너리
- 일반적: JSON (하이브리드)
4️⃣ 엔디언 (Big-Endian)
4.1 엔디언이란
엔디언 (Endianness):
다중 바이트 데이터의 저장 순서.
Big-Endian (BE):
- 큰 자리부터 (사람 읽는 순서)
- 0x12345678 → 12 34 56 78
- 네트워크 표준 (network byte order)
Little-Endian (LE):
- 작은 자리부터
- 0x12345678 → 78 56 34 12
- x86 CPU 의 표준4.2 자바의 선택
자바의 DataOutputStream:
→ 항상 Big-Endian
이유:
- 자바는 플랫폼 독립적
- JVM 이 어디서든 같은 결과
- 네트워크 표준 (BE) 와 일치
영향:
- C/C++ 와 다를 수 있음 (x86 은 LE)
- 자바 ↔ C 통신 시 변환 필요4.3 시각화
// int 0x12345678 쓰기
dos.writeInt(0x12345678);
// 파일에 저장된 바이트:
// 12 34 56 78 (Big-Endian)
// hex dump:
$ xxd file.bin
00000000: 1234 5678 .4Vx4.4 NIO 의 ByteOrder
// NIO 의 ByteBuffer 는 엔디언 변경 가능
ByteBuffer buf = ByteBuffer.allocate(4);
buf.order(ByteOrder.BIG_ENDIAN); // 기본
buf.putInt(0x12345678);
// [0x12, 0x34, 0x56, 0x78]
buf.clear();
buf.order(ByteOrder.LITTLE_ENDIAN);
buf.putInt(0x12345678);
// [0x78, 0x56, 0x34, 0x12]
// 시스템 기본
ByteOrder nativeOrder = ByteOrder.nativeOrder();
// x86: LITTLE_ENDIAN
// PowerPC: BIG_ENDIAN
// DataOutputStream 은 항상 BE
// LE 가 필요하면 ByteBuffer 사용4.5 C ↔ 자바 호환
// C 코드 (x86, Little-Endian):
// int value = 0x12345678;
// fwrite(&value, sizeof(int), 1, file);
// 파일: 78 56 34 12
// 자바 코드 (Big-Endian):
// dos.writeInt(0x12345678);
// 파일: 12 34 56 78
// 둘은 다른 형식!
// 호환하려면:
public int readLittleEndianInt(DataInputStream dis) throws IOException {
int b1 = dis.read();
int b2 = dis.read();
int b3 = dis.read();
int b4 = dis.read();
return (b4 << 24) | (b3 << 16) | (b2 << 8) | b1;
}
// 또는 ByteBuffer
public int readLittleEndianInt(byte[] bytes) {
return ByteBuffer.wrap(bytes)
.order(ByteOrder.LITTLE_ENDIAN)
.getInt();
}4.6 네트워크 프로토콜
대부분 네트워크 프로토콜: Big-Endian
- TCP/IP
- HTTP
- 대부분 표준
이유:
- 1980 년대 표준화 (당시 BE 가 많음)
- "network byte order" = BE
자바의 장점:
- DataOutputStream 이 BE
- 네트워크와 자연스럽게 호환
- htonl, ntohl 같은 변환 불필요4.7 ILIC 활용
public class NetworkProtocol {
// 자바 ↔ 자바 (BE)
public void sendMessage(Socket socket, int messageId, String content)
throws IOException {
try (DataOutputStream dos = new DataOutputStream(socket.getOutputStream())) {
dos.writeInt(messageId); // BE
dos.writeUTF(content);
}
}
public Message receiveMessage(Socket socket) throws IOException {
try (DataInputStream dis = new DataInputStream(socket.getInputStream())) {
int messageId = dis.readInt(); // BE
String content = dis.readUTF();
return new Message(messageId, content);
}
}
// 자바 ↔ C/C++ (LE)
public int readCInt(InputStream is) throws IOException {
byte[] buf = new byte[4];
if (is.read(buf) != 4) throw new EOFException();
// C 코드가 LE 면
return ByteBuffer.wrap(buf)
.order(ByteOrder.LITTLE_ENDIAN)
.getInt();
}
}4.8 자기 점검 답변
엔디언과 자바의 선택은?
답:
1. 엔디언:
- Big-Endian: 큰 자리부터
- Little-Endian: 작은 자리부터
-
자바의 선택:
- DataOutputStream: 항상 BE
- 네트워크 표준
- 플랫폼 독립적
-
C/C++ 호환:
- x86 는 LE
- 자바와 다름
- ByteBuffer 로 변환
-
NIO ByteBuffer:
- order(ByteOrder) 변경 가능
- 양쪽 지원
5️⃣ readUTF / writeUTF 의 Modified UTF-8
5.1 Modified UTF-8 의 정의
Modified UTF-8:
자바의 특별한 문자열 직렬화 형식.
표준 UTF-8 과 살짝 다름.
형식:
[길이 (2바이트, unsigned short)]
[Modified UTF-8 인코딩 데이터]
특징:
- 길이 정보 포함 (앞 2바이트)
- 최대 65535 바이트
- null 문자 (\0) 의 특별 처리
- Supplementary 문자의 다른 처리5.2 표준 UTF-8 과의 차이
차이 1: null 문자
표준 UTF-8: 0x00 (1바이트)
Modified UTF-8: 0xC0 0x80 (2바이트)
이유: C 의 null-terminated 문자열과 충돌 회피
차이 2: Supplementary 문자 (BMP 외)
표준 UTF-8: 4바이트
Modified UTF-8: Surrogate Pair 의 각 char 를 3바이트로
→ 총 6바이트
이모지 😀 (U+1F600):
UTF-8: 0xF0 0x9F 0x98 0x80 (4바이트)
Modified UTF-8: 0xED 0xA0 0xBD + 0xED 0xB8 0x80 (6바이트)5.3 writeUTF 의 동작
public void writeUTF(String str) throws IOException;
// 동작:
// 1. str 의 Modified UTF-8 길이 계산
// 2. 길이가 65535 초과면 UTFDataFormatException
// 3. 2바이트 길이 쓰기 (Big-Endian)
// 4. Modified UTF-8 데이터 쓰기
// 예: writeUTF("안녕")
// "안" = 0xEC 0x95 0x88 (3바이트, Modified UTF-8)
// "녕" = 0xEB 0x85 0x95 (3바이트)
// 길이 = 6
// 결과: 0x00 0x06 0xEC 0x95 0x88 0xEB 0x85 0x95
// [길이][데이터]
// 총 8바이트5.4 readUTF 의 동작
public String readUTF() throws IOException;
// 동작:
// 1. 2바이트 길이 읽기 (BE)
// 2. 그만큼 데이터 읽기
// 3. Modified UTF-8 디코딩
// 4. String 반환
// 예: 앞 예의 바이트 읽기
// readUTF() → "안녕"
// 또는 정적 메서드
String s = DataInputStream.readUTF(dis);5.5 길이 제한
// 65535 바이트 제한
String huge = "x".repeat(70000);
try {
dos.writeUTF(huge);
} catch (UTFDataFormatException e) {
// 길이 초과
}
// 한글 문자열의 경우:
// 한 글자 3바이트 (Modified UTF-8)
// 최대 약 21,845 한글 글자
// 큰 문자열은 다른 방법
// 1. 청크 분할
// 2. 길이를 int (4바이트) 로 쓰고 byte[] 쓰기
public void writeLongString(DataOutput dos, String s) throws IOException {
byte[] bytes = s.getBytes(StandardCharsets.UTF_8);
dos.writeInt(bytes.length);
dos.write(bytes);
}
public String readLongString(DataInput dis) throws IOException {
int len = dis.readInt();
byte[] bytes = new byte[len];
dis.readFully(bytes);
return new String(bytes, StandardCharsets.UTF_8);
}5.6 활용 시점
writeUTF / readUTF:
- 짧은 문자열 (< 65535 바이트)
- 자바 ↔ 자바 통신
- 직렬화
표준 UTF-8 권장:
- 긴 문자열
- 다른 언어와 통신
- 표준 호환5.7 자바 ↔ 다른 언어
// 자바 (Modified UTF-8)
dos.writeUTF("Hello");
// 파일: 00 05 48 65 6C 6C 6F
// C 에서 읽기 (표준 UTF-8 이라고 가정)
// 만약 ASCII 만 이라면:
// 처음 2바이트 무시 (길이)
// 그 다음 5바이트 = "Hello"
// 운 좋게 호환
// 한글이라면:
// 자바: Modified UTF-8
// C: 표준 UTF-8
// 깨질 수 있음 (null 문자, Supplementary)
// 안전 호환:
public void writeStandardUtf8(DataOutput dos, String s) throws IOException {
byte[] bytes = s.getBytes(StandardCharsets.UTF_8);
dos.writeInt(bytes.length);
dos.write(bytes);
}5.8 ILIC 활용
public class ShipmentDataSerializer {
// 일반 (자바 ↔ 자바)
public void writeNormal(DataOutputStream dos, Shipment s) throws IOException {
dos.writeLong(s.getId());
dos.writeUTF(s.getBlNo()); // 짧음
dos.writeUTF(s.getConsignee()); // 짧음
}
// 긴 텍스트 — 표준 UTF-8
public void writeLongText(DataOutputStream dos, String text) throws IOException {
byte[] bytes = text.getBytes(StandardCharsets.UTF_8);
dos.writeInt(bytes.length);
dos.write(bytes);
}
public String readLongText(DataInputStream dis) throws IOException {
int len = dis.readInt();
byte[] bytes = new byte[len];
dis.readFully(bytes);
return new String(bytes, StandardCharsets.UTF_8);
}
// 옵션: writeUTF 또는 long text
public void writeText(DataOutputStream dos, String s) throws IOException {
byte[] bytes = s.getBytes(StandardCharsets.UTF_8);
if (bytes.length <= 65535) {
dos.writeBoolean(false); // short UTF
dos.writeUTF(s);
} else {
dos.writeBoolean(true); // long text
writeLongText(dos, s);
}
}
public String readText(DataInputStream dis) throws IOException {
boolean longText = dis.readBoolean();
return longText ? readLongText(dis) : dis.readUTF();
}
}5.9 자기 점검 답변
Modified UTF-8 와 표준 UTF-8 의 차이는?
답:
1. Modified UTF-8 형식:
- [길이 2바이트][데이터]
- 최대 65535 바이트
-
차이:
- null 문자: 0xC0 0x80 (2바이트)
- Supplementary: Surrogate Pair 각 3바이트 (총 6)
-
이유:
- C 의 null-terminated 충돌 회피
- 자바 내부 처리
-
활용:
- 자바 ↔ 자바: writeUTF OK
- 다른 언어: 표준 UTF-8 권장
- 긴 텍스트: writeInt + byte[]
-
한계:
- 65535 바이트
- 한글 약 21,845 글자
6️⃣ readFully — 정확한 읽기
6.1 read 와 readFully 의 차이
// read(byte[]) — 부분 읽기 가능
public int read(byte[] b) throws IOException;
// 반환: 실제 읽은 수 (< b.length 가능)
// EOF: -1
// readFully — 정확히 채움
public void readFully(byte[] b) throws IOException;
public void readFully(byte[] b, int off, int len) throws IOException;
// 정확히 b.length (또는 len) 만큼
// 부족하면 EOFException6.2 시나리오 비교
// 파일 크기 100바이트
byte[] buf = new byte[150];
// read 의 동작
int n = fis.read(buf);
// n = 100 (부분만)
// EOF 도달
// readFully 의 동작
try {
dis.readFully(buf);
} catch (EOFException e) {
// 100 < 150 이므로 예외
}
// readFully(buf, 0, 50) — 50 바이트만
dis.readFully(buf, 0, 50);
// buf[0~49] 채워짐
// 정상 (100 ≥ 50)6.3 readFully 가 필요한 시점
필요한 경우:
1. 헤더 읽기
- 정확한 크기 보장
- 부족하면 형식 오류
2. 기본 타입 읽기
- readInt 의 4바이트
- 부족하면 데이터 손상
3. 프로토콜 파싱
- 정확한 크기로 분할
- 길이 + 페이로드
readInt 의 내부:
public int readInt() throws IOException {
int ch1 = in.read();
int ch2 = in.read();
int ch3 = in.read();
int ch4 = in.read();
if ((ch1 | ch2 | ch3 | ch4) < 0)
throw new EOFException();
return (ch1 << 24) + (ch2 << 16) + (ch3 << 8) + ch4;
}
// 부족하면 EOFException6.4 readFully 의 구현
public void readFully(byte b[], int off, int len) throws IOException {
if (len < 0) throw new IndexOutOfBoundsException();
int n = 0;
while (n < len) {
int count = in.read(b, off + n, len - n);
if (count < 0) throw new EOFException();
n += count;
}
}
// 동작:
// 1. n < len 동안 read 반복
// 2. read 가 -1 반환 → EOFException
// 3. 정확히 len 바이트 채움6.5 활용 — 헤더 파싱
public class FileHeader {
int magic;
int version;
long size;
String name;
}
public FileHeader readHeader(DataInputStream dis) throws IOException {
FileHeader h = new FileHeader();
// 매직 넘버
h.magic = dis.readInt(); // 정확히 4바이트
if (h.magic != 0xDEADBEEF) {
throw new IOException("Invalid magic");
}
// 버전
h.version = dis.readInt();
// 크기
h.size = dis.readLong();
// 이름
h.name = dis.readUTF();
return h;
}
// 헤더 모두 정확히 읽음
// 부족 시 EOFException6.6 readNBytes (Java 9+) 와 비교
// readFully — 부족 시 예외
dis.readFully(buf);
// readNBytes — 부족 시 작은 배열 반환
byte[] data = is.readNBytes(100);
// data.length 가 100 또는 그 이하
// 차이:
// - readFully: 엄격, EOF 면 예외
// - readNBytes: 유연, EOF 까지 읽음
// 선택:
// - 정확한 크기 필요: readFully
// - 가능한 만큼: readNBytes6.7 ILIC 활용
public class ShipmentRecordReader {
// 고정 길이 레코드
public List<ShipmentRecord> readFixedRecords(Path path) throws IOException {
List<ShipmentRecord> records = new ArrayList<>();
try (DataInputStream dis = new DataInputStream(
new BufferedInputStream(
new FileInputStream(path.toFile())))) {
byte[] buf = new byte[ShipmentRecord.SIZE];
try {
while (true) {
dis.readFully(buf); // 정확히 SIZE
records.add(ShipmentRecord.parse(buf));
}
} catch (EOFException e) {
// 정상 종료 (파일 끝)
}
}
return records;
}
// 헤더 + 가변 본문
public Message readMessage(DataInputStream dis) throws IOException {
// 헤더 (16바이트)
byte[] header = new byte[16];
dis.readFully(header);
int magic = ByteBuffer.wrap(header, 0, 4).getInt();
int version = ByteBuffer.wrap(header, 4, 4).getInt();
int bodyLen = ByteBuffer.wrap(header, 8, 4).getInt();
int crc = ByteBuffer.wrap(header, 12, 4).getInt();
// 본문
byte[] body = new byte[bodyLen];
dis.readFully(body);
// CRC 검증
if (computeCrc(body) != crc) {
throw new IOException("CRC mismatch");
}
return new Message(magic, version, body);
}
}6.8 자기 점검 답변
readFully vs read 의 차이는?
답:
1. read(byte[]):
- 부분 읽기 가능
- 반환: 실제 수, -1 EOF
-
readFully:
- 정확히 채움
- 부족 시 EOFException
-
필요 시점:
- 헤더 (고정 크기)
- 기본 타입 (readInt 등)
- 프로토콜 파싱
-
내부:
- while 루프 + read
- -1 시 EOFException
-
readNBytes (Java 9+):
- 유연 (EOF 까지)
- readFully 와 다름
7️⃣ DataInput / DataOutput 인터페이스
7.1 DataInput 인터페이스
package java.io;
public interface DataInput {
void readFully(byte b[]) throws IOException;
void readFully(byte b[], int off, int len) throws IOException;
int skipBytes(int n) throws IOException;
boolean readBoolean() throws IOException;
byte readByte() throws IOException;
int readUnsignedByte() throws IOException;
short readShort() throws IOException;
int readUnsignedShort() throws IOException;
char readChar() throws IOException;
int readInt() throws IOException;
long readLong() throws IOException;
float readFloat() throws IOException;
double readDouble() throws IOException;
String readLine() throws IOException;
String readUTF() throws IOException;
}7.2 DataOutput 인터페이스
public interface DataOutput {
void write(int b) throws IOException;
void write(byte b[]) throws IOException;
void write(byte b[], int off, int len) throws IOException;
void writeBoolean(boolean v) throws IOException;
void writeByte(int v) throws IOException;
void writeShort(int v) throws IOException;
void writeChar(int v) throws IOException;
void writeInt(int v) throws IOException;
void writeLong(long v) throws IOException;
void writeFloat(float v) throws IOException;
void writeDouble(double v) throws IOException;
void writeBytes(String s) throws IOException;
void writeChars(String s) throws IOException;
void writeUTF(String s) throws IOException;
}7.3 구현 클래스
DataInput 의 구현:
- DataInputStream (가장 일반)
- RandomAccessFile
- ObjectInputStream
DataOutput 의 구현:
- DataOutputStream
- RandomAccessFile
- ObjectOutputStream
핵심:
- 인터페이스로 추상화
- 다양한 구현
- 다형성 활용7.4 RandomAccessFile
// 양방향 + 임의 접근
RandomAccessFile raf = new RandomAccessFile("file.dat", "rw");
// DataInput 메서드
int i = raf.readInt();
String s = raf.readUTF();
// DataOutput 메서드
raf.writeInt(42);
raf.writeUTF("Hello");
// 위치 이동
raf.seek(100);
raf.getFilePointer(); // 현재 위치
raf.length(); // 파일 크기
// 사용 시점:
// - Random Access
// - 양방향
// - 단, NIO 의 FileChannel 이 더 권장7.5 ObjectInputStream 의 활용
// ObjectInputStream 도 DataInput
ObjectInputStream ois = new ObjectInputStream(in);
// 기본 타입 메서드
int i = ois.readInt();
long l = ois.readLong();
String s = ois.readUTF();
// 객체 메서드
Object obj = ois.readObject();
// 다음 Unit 의 토대7.6 다형성 활용
// 메서드가 인터페이스 받음
public void process(DataInput input) throws IOException {
int id = input.readInt();
String name = input.readUTF();
// ...
}
// 다양한 호출
DataInputStream dis = ...;
process(dis);
RandomAccessFile raf = ...;
process(raf);
ObjectInputStream ois = ...;
process(ois);
// 같은 인터페이스, 다른 구현7.7 ILIC 활용
public class ShipmentSerializer {
// DataInput / DataOutput 으로 추상화
public void writeShipment(DataOutput out, Shipment s) throws IOException {
out.writeLong(s.getId());
out.writeUTF(s.getBlNo());
out.writeDouble(s.getWeight().doubleValue());
out.writeBoolean(s.isActive());
}
public Shipment readShipment(DataInput in) throws IOException {
return Shipment.builder()
.id(in.readLong())
.blNo(in.readUTF())
.weight(BigDecimal.valueOf(in.readDouble()))
.active(in.readBoolean())
.build();
}
// 다양한 호출
public void saveToFile(Path path, Shipment s) throws IOException {
try (DataOutputStream dos = new DataOutputStream(
new BufferedOutputStream(
new FileOutputStream(path.toFile())))) {
writeShipment(dos, s);
}
}
public void saveToRandom(Path path, Shipment s, long offset) throws IOException {
try (RandomAccessFile raf = new RandomAccessFile(path.toFile(), "rw")) {
raf.seek(offset);
writeShipment(raf, s);
}
}
public void serializeWithObject(OutputStream os, Shipment s) throws IOException {
try (ObjectOutputStream oos = new ObjectOutputStream(os)) {
writeShipment(oos, s);
// 추가로 객체로도 저장 가능
oos.writeObject(s);
}
}
}7.8 자기 점검 답변
DataInput / DataOutput 인터페이스의 역할은?
답:
1. 정의:
- 기본 타입 read/write 의 추상화
- 인터페이스
-
구현 클래스:
- DataInputStream/OutputStream (가장 일반)
- RandomAccessFile (양방향 + Random)
- ObjectInputStream/OutputStream (직렬화)
-
활용:
- 다형성
- 메서드 인자로 인터페이스
- 다양한 구현 호환
-
RandomAccessFile:
- 양방향 + 임의 접근
- seek, getFilePointer
8️⃣ 실무 활용과 함정
8.1 권장 패턴
// 패턴 1: 기본 (Buffered + Data)
try (DataOutputStream dos = new DataOutputStream(
new BufferedOutputStream(
new FileOutputStream(path.toFile())))) {
dos.writeInt(42);
dos.writeUTF("Hello");
}
// 패턴 2: 압축
try (DataOutputStream dos = new DataOutputStream(
new GZIPOutputStream(
new BufferedOutputStream(
new FileOutputStream(path.toFile()))))) {
dos.writeInt(42);
}
// 패턴 3: 메모리
try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
DataOutputStream dos = new DataOutputStream(baos)) {
dos.writeInt(42);
dos.writeUTF("Hello");
byte[] result = baos.toByteArray();
}
// 패턴 4: 네트워크
try (DataOutputStream dos = new DataOutputStream(socket.getOutputStream())) {
dos.writeInt(messageType);
dos.writeUTF(payload);
}8.2 흔한 함정 종합
함정 1: 순서 불일치
// 쓰기
dos.writeInt(id);
dos.writeUTF(name);
// 읽기 — 잘못된 순서
String name = dis.readUTF(); // ❌ int 를 UTF 로
→ 데이터 손상
함정 2: 타입 불일치
// 쓰기
dos.writeLong(id); // 8바이트
// 읽기
int id = dis.readInt(); // 4바이트만 ❌
→ 다음 데이터 깨짐
함정 3: read 와 readFully 혼동
// 부족하면 무시 vs 예외
// 기본 타입은 readFully 가 안전
함정 4: readUTF 의 65535 제한
// 큰 텍스트 → UTFDataFormatException
// 해결: int 길이 + byte[]
함정 5: 엔디언 (C 와 통신)
// 자바: BE
// C/x86: LE
// ByteBuffer 변환
함정 6: char 의 2바이트
// writeChar 는 2바이트 (UTF-16)
// ASCII 만이면 writeByte 가 작음
함정 7: 형식 버전 관리
// 형식 바뀌면 옛 데이터 못 읽음
// 버전 필드 권장8.3 버전 관리
// 파일 형식의 버전 관리
public class ShipmentFile {
private static final int MAGIC = 0xDEADBEEF;
private static final int VERSION_1 = 1;
private static final int VERSION_2 = 2;
private static final int CURRENT_VERSION = VERSION_2;
public void write(DataOutputStream dos, Shipment s) throws IOException {
// 헤더
dos.writeInt(MAGIC);
dos.writeInt(CURRENT_VERSION);
// 데이터
dos.writeLong(s.getId());
dos.writeUTF(s.getBlNo());
if (CURRENT_VERSION >= VERSION_2) {
// 새 필드
dos.writeBoolean(s.isUrgent());
}
}
public Shipment read(DataInputStream dis) throws IOException {
int magic = dis.readInt();
if (magic != MAGIC) throw new IOException("Invalid format");
int version = dis.readInt();
Shipment.Builder builder = Shipment.builder()
.id(dis.readLong())
.blNo(dis.readUTF());
if (version >= VERSION_2) {
builder.urgent(dis.readBoolean());
}
return builder.build();
}
}8.4 ILIC 의 종합 활용
@Service
public class ShipmentBinaryService {
private static final int MAGIC = 0xDEADBEEF;
private static final int VERSION = 1;
// 1. 효율적 저장
public void saveCompact(Path path, List<Shipment> shipments) throws IOException {
try (DataOutputStream dos = new DataOutputStream(
new BufferedOutputStream(
new GZIPOutputStream(
new FileOutputStream(path.toFile()))))) {
// 헤더
dos.writeInt(MAGIC);
dos.writeInt(VERSION);
dos.writeInt(shipments.size());
// 데이터
for (Shipment s : shipments) {
dos.writeLong(s.getId());
dos.writeUTF(s.getBlNo());
dos.writeUTF(s.getConsignee());
dos.writeDouble(s.getWeight().doubleValue());
dos.writeLong(s.getCreatedAt().toEpochMilli());
}
}
}
// 2. 로드 + 검증
public List<Shipment> loadCompact(Path path) throws IOException {
try (DataInputStream dis = new DataInputStream(
new BufferedInputStream(
new GZIPInputStream(
new FileInputStream(path.toFile()))))) {
// 헤더 검증
int magic = dis.readInt();
if (magic != MAGIC) throw new IOException("Invalid magic");
int version = dis.readInt();
if (version != VERSION) throw new IOException("Unsupported version");
int count = dis.readInt();
List<Shipment> shipments = new ArrayList<>(count);
for (int i = 0; i < count; i++) {
Shipment s = Shipment.builder()
.id(dis.readLong())
.blNo(dis.readUTF())
.consignee(dis.readUTF())
.weight(BigDecimal.valueOf(dis.readDouble()))
.createdAt(Instant.ofEpochMilli(dis.readLong()))
.build();
shipments.add(s);
}
return shipments;
}
}
// 3. 네트워크 프로토콜
public void sendShipment(Socket socket, Shipment s) throws IOException {
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
// 메시지 타입 + 페이로드
dos.writeInt(1); // SHIPMENT_MESSAGE
dos.writeLong(s.getId());
dos.writeUTF(s.getBlNo());
dos.flush();
}
public Shipment receiveShipment(Socket socket) throws IOException {
DataInputStream dis = new DataInputStream(socket.getInputStream());
int type = dis.readInt();
if (type != 1) throw new IOException("Unexpected type: " + type);
return Shipment.builder()
.id(dis.readLong())
.blNo(dis.readUTF())
.build();
}
// 4. 크기 측정
public int measureSize(Shipment s) throws IOException {
try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
DataOutputStream dos = new DataOutputStream(baos)) {
dos.writeLong(s.getId());
dos.writeUTF(s.getBlNo());
return dos.size();
}
}
}8.5 자기 점검 답변
실무 활용과 함정?
답:
1. 권장 패턴:
- DataOutputStream + BufferedOutputStream
- 압축 결합
- 메모리에 직렬화
-
흔한 함정 7가지:
- 순서 불일치
- 타입 불일치
- read vs readFully
- readUTF 65535 제한
- 엔디언 (C 호환)
- char 의 2바이트
- 버전 관리
-
버전 관리:
- MAGIC + VERSION 헤더
- 새 필드 추가 시 호환
-
다음 Unit (직렬화) 의 토대
9️⃣ 면접 + 자기 점검
9.1 면접 단골 질문 매핑
| Q | 핵심 답변 |
|---|---|
| DataInputStream 정의? | FilterInputStream, DataInput |
| 기본 타입 메서드? | readInt, readLong, readDouble, readUTF |
| 바이너리 vs 텍스트? | 고정 크기, 빠름 vs 가독성 |
| 엔디언? | 자바 Big-Endian (네트워크 표준) |
| readUTF 형식? | Modified UTF-8, 길이 2바이트 + 데이터 |
| readUTF 한계? | 65535 바이트 |
| readFully vs read? | 정확히 채움 vs 부분 |
| DataInput/Output 인터페이스? | 다형성, 다양한 구현 |
| RandomAccessFile? | 양방향 + Random Access |
| 직렬화와 관계? | DataInput/Output 의 확장 |
9.2 자기 점검 체크리스트
정의
- DataInputStream / DataOutputStream
- FilterInputStream/OutputStream 자식
- DataInput / DataOutput 인터페이스
메서드
- readBoolean ~ readDouble
- writeBoolean ~ writeDouble
- readUTF / writeUTF
- readFully
- 타입별 바이트 크기
형식
- 바이너리 vs 텍스트
- 엔디언 (BE)
- Modified UTF-8
- writeUTF 의 형식 ([길이][데이터])
실무
- BufferedStream 결합
- 압축 결합
- 버전 관리
- 흔한 함정
9.3 추가 심화 질문
Q1: writeUTF 의 정확한 형식?
답:
[unsigned short 길이][Modified UTF-8 데이터]
- 길이: 2바이트, BE
- 데이터의 바이트 수 (글자 수 X)
- 최대 65535
예: "안녕"
Modified UTF-8: 6바이트
파일: 0x00 0x06 0xEC 0x95 0x88 0xEB 0x85 0x95
[길이 6][데이터 6바이트]Q2: DataInputStream 의 동시성?
답:
- 외부 동기화 권장
- 메서드 자체는 not synchronized
- 단, 감싼 stream 이 synchronized 면 안전 (BufferedInputStream 등)
Q3: readInt 가 부족하면?
답:
// 3바이트만 남았는데 readInt
try {
int i = dis.readInt();
} catch (EOFException e) {
// 4바이트 못 채움
}
// 안전: 항상 try-catchQ4: writeFloat 의 정밀도?
답:
- IEEE 754 single precision
- 32비트 (4바이트)
- 부호 1 + 지수 8 + 가수 23
- 약 7자리 정확
- 큰 수는 정밀도 손실
dos.writeFloat(1.123456789f);
float f = dis.readFloat();
// f ≈ 1.1234568 (정밀도 손실)Q5: ObjectInputStream 도 DataInput?
답:
- 예, ObjectInputStream extends InputStream implements ObjectInput
- ObjectInput extends DataInput
- 기본 타입 메서드 + 객체 메서드
- 다음 Unit 의 주제
🎯 핵심 요약 — 3줄 정리
1. DataInputStream / DataOutputStream
- 기본 타입 ↔ 바이너리
- readInt, readUTF 등
- DataInput / DataOutput 인터페이스
2. 특징
- 자바는 Big-Endian
- writeUTF 의 Modified UTF-8 (65535 제한)
- readFully = 정확히 채움
3. 실무
- BufferedStream 결합
- 버전 관리 (헤더)
- 다음 Unit (직렬화) 의 토대
📚 다음으로...
Unit 9.4 — Serialization (직렬화)
이번 Unit에서 기본 타입 입출력을 봤다면, 다음은 객체 직렬화.
- Serializable 인터페이스
- ObjectInputStream / ObjectOutputStream
- 객체 그래프
- transient 키워드
- 보안 고려사항
Phase 9 진행 상황
🚀 Phase 9 — I/O 강화
✅ Unit 9.1 try-with-resources
✅ Unit 9.2 BufferedInputStream / BufferedOutputStream
✅ Unit 9.3 DataInputStream / DataOutputStream ← 여기
⏭ Unit 9.4 Serialization (직렬화)
⏭ Unit 9.5 serialVersionUID3주차 누적 진행
✅ Phase 1 ~ 8 완주 (37 Unit)
🚀 Phase 9 — I/O 강화 (3/5 진행)
총: 40/43 Unit (약 93%)
Software Developer