201 lines
5.5 KiB
Markdown
201 lines
5.5 KiB
Markdown
## 자바 IO (Input/Output) 관련 클래스 및 주요 메서드 정리
|
|
|
|
자바 IO는 **데이터를 스트림(Stream) 기반으로 읽고 쓰는 전통적인 입출력 API**다.
|
|
주로 **파일, 콘솔, 네트워크, 메모리 등과 데이터를 주고받는 데 사용**된다.
|
|
|
|
---
|
|
|
|
### 1. `InputStream` (바이트 입력 스트림)
|
|
|
|
| 메서드 | 설명 |
|
|
|--------|------------------------------|
|
|
| `read()` | 1바이트를 읽고 정수(0~255)로 반환, 끝이면 -1 반환 |
|
|
| `read(byte[] b)` | 바이트 배열에 데이터를 읽음 |
|
|
| `available()` | 읽을 수 있는 바이트 수 반환 |
|
|
| `close()` | 스트림 닫기 |
|
|
|
|
**주요 하위 클래스:**
|
|
- `FileInputStream` (파일에서 바이트 읽기)
|
|
- `ByteArrayInputStream` (바이트 배열에서 읽기)
|
|
- `BufferedInputStream` (버퍼링으로 성능 향상)
|
|
|
|
---
|
|
|
|
### 2. `OutputStream` (바이트 출력 스트림)
|
|
|
|
| 메서드 | 설명 |
|
|
|--------|------------------------------|
|
|
| `write(int b)` | 1바이트 쓰기 |
|
|
| `write(byte[] b)` | 바이트 배열을 스트림에 쓰기 |
|
|
| `flush()` | 버퍼에 있는 데이터를 즉시 출력 |
|
|
| `close()` | 스트림 닫기 |
|
|
|
|
**주요 하위 클래스:**
|
|
- `FileOutputStream` (파일에 바이트 쓰기)
|
|
- `ByteArrayOutputStream` (바이트 배열에 쓰기)
|
|
- `BufferedOutputStream` (버퍼링으로 성능 향상)
|
|
|
|
---
|
|
|
|
### 3. `Reader` (문자 입력 스트림)
|
|
|
|
| 메서드 | 설명 |
|
|
|--------|------------------------------|
|
|
| `read()` | 문자 하나 읽기 |
|
|
| `read(char[] cbuf)` | 문자 배열에 읽기 |
|
|
| `close()` | 스트림 닫기 |
|
|
|
|
**주요 하위 클래스:**
|
|
- `FileReader` (파일에서 문자 읽기)
|
|
- `BufferedReader` (버퍼링으로 성능 향상)
|
|
- `StringReader` (문자열에서 읽기)
|
|
|
|
---
|
|
|
|
### 4. `Writer` (문자 출력 스트림)
|
|
|
|
| 메서드 | 설명 |
|
|
|--------|------------------------------|
|
|
| `write(int c)` | 문자 하나 쓰기 |
|
|
| `write(char[] cbuf)` | 문자 배열을 스트림에 쓰기 |
|
|
| `flush()` | 버퍼 비우기 |
|
|
| `close()` | 스트림 닫기 |
|
|
|
|
**주요 하위 클래스:**
|
|
- `FileWriter` (파일에 문자 쓰기)
|
|
- `BufferedWriter` (버퍼링으로 성능 향상)
|
|
- `StringWriter` (문자열에 쓰기)
|
|
|
|
---
|
|
|
|
### 5. `File` 클래스 (파일 및 디렉토리 관리)
|
|
|
|
| 메서드 | 설명 |
|
|
|--------|------------------------------|
|
|
| `exists()` | 파일이 존재하는지 확인 |
|
|
| `createNewFile()` | 새 파일 생성 |
|
|
| `delete()` | 파일 삭제 |
|
|
| `mkdir()` | 새 디렉토리 생성 |
|
|
| `listFiles()` | 디렉토리 내 파일 목록 반환 |
|
|
|
|
---
|
|
|
|
### 6. `BufferedReader`와 `BufferedWriter` (성능 향상)
|
|
|
|
| 메서드 | 설명 |
|
|
|--------|------------------------------|
|
|
| `readLine()` | 한 줄씩 읽기 (`BufferedReader` 전용) |
|
|
| `write(String s)` | 문자열 출력 (`BufferedWriter` 전용) |
|
|
| `flush()` | 버퍼 비우기 |
|
|
| `close()` | 스트림 닫기 |
|
|
|
|
---
|
|
|
|
### 자바 IO 쉽게 설명하기
|
|
|
|
자바의 IO는 데이터를 **스트림(Stream) 기반으로 입출력**하는 방식이다.
|
|
즉, **한 번에 하나의 데이터(바이트 or 문자)를 순차적으로 처리**하는 구조다.
|
|
|
|
---
|
|
|
|
### 1. **파일에서 데이터 읽기 (`FileReader`)**
|
|
|
|
```java
|
|
FileReader reader = new FileReader("example.txt");
|
|
int data;
|
|
while ((data = reader.read()) != -1) {
|
|
System.out.print((char) data);
|
|
}
|
|
reader.close();
|
|
```
|
|
- `read()` → 한 글자씩 읽음
|
|
- `close()` → 파일 닫기
|
|
|
|
---
|
|
|
|
### 2. **파일에 데이터 쓰기 (`FileWriter`)**
|
|
|
|
```java
|
|
FileWriter writer = new FileWriter("example.txt");
|
|
writer.write("Hello, Java IO!");
|
|
writer.close();
|
|
```
|
|
- `write()` → 파일에 문자열 저장
|
|
- `close()` → 파일 닫기
|
|
|
|
---
|
|
|
|
### 3. **파일을 빠르게 읽기 (`BufferedReader`)**
|
|
|
|
```java
|
|
BufferedReader br = new BufferedReader(new FileReader("example.txt"));
|
|
String line;
|
|
while ((line = br.readLine()) != null) {
|
|
System.out.println(line);
|
|
}
|
|
br.close();
|
|
```
|
|
- `readLine()` → 한 줄씩 읽기 (효율적)
|
|
- `BufferedReader` → 버퍼링으로 속도 향상
|
|
|
|
---
|
|
|
|
### 4. **파일을 빠르게 쓰기 (`BufferedWriter`)**
|
|
|
|
```java
|
|
BufferedWriter bw = new BufferedWriter(new FileWriter("example.txt"));
|
|
bw.write("Buffered Writer 사용!");
|
|
bw.newLine(); // 줄바꿈
|
|
bw.close();
|
|
```
|
|
- `newLine()` → 줄바꿈 추가
|
|
- `BufferedWriter` → 속도 향상
|
|
|
|
---
|
|
|
|
### 5. **바이트 단위 파일 복사 (`FileInputStream`, `FileOutputStream`)**
|
|
|
|
```java
|
|
FileInputStream fis = new FileInputStream("input.txt");
|
|
FileOutputStream fos = new FileOutputStream("output.txt");
|
|
|
|
int data;
|
|
while ((data = fis.read()) != -1) {
|
|
fos.write(data);
|
|
}
|
|
|
|
fis.close();
|
|
fos.close();
|
|
```
|
|
- `read()` → 1바이트씩 읽기
|
|
- `write()` → 1바이트씩 출력
|
|
|
|
---
|
|
|
|
### 6. **문자 단위 파일 복사 (`FileReader`, `FileWriter`)**
|
|
|
|
```java
|
|
FileReader fr = new FileReader("input.txt");
|
|
FileWriter fw = new FileWriter("output.txt");
|
|
|
|
int data;
|
|
while ((data = fr.read()) != -1) {
|
|
fw.write(data);
|
|
}
|
|
|
|
fr.close();
|
|
fw.close();
|
|
```
|
|
- `FileReader` → 문자 기반 파일 읽기
|
|
- `FileWriter` → 문자 기반 파일 쓰기
|
|
|
|
---
|
|
|
|
### 정리
|
|
|
|
자바 IO는 **스트림 기반으로 데이터를 읽고 쓰는 방식**을 제공한다.
|
|
- **바이트 단위 (`InputStream`, `OutputStream`)** → 이미지, 동영상, 바이너리 파일 처리
|
|
- **문자 단위 (`Reader`, `Writer`)** → 텍스트 파일 처리
|
|
- **버퍼링 (`BufferedReader`, `BufferedWriter`)** → 성능 최적화
|
|
|
|
**즉, IO 스트림을 적절히 활용하면 다양한 입출력 작업을 쉽게 수행할 수 있다!** |