Week13(I/O)
์คํธ๋ฆผ (Stream) / ๋ฒํผ (Buffer) / ์ฑ๋ (Channel) ๊ธฐ๋ฐ์ I/O
์คํธ๋ฆผ (Stream)
์คํธ๋ฆผ( Stream )์ด๋ ๋จ์ผ ๋ฐฉํฅ์ผ๋ก ์ฐ์์ ์ผ๋ก ํ๋ฌ๊ฐ๋ ๊ฒ์ ์๋ฏธํ๋ค.
์ฆ, ์๋ฃ์ ์ ์ถ๋ ฅ์ ๋์์ฃผ๋ ์ค๊ฐ ๋งค๊ฐ์ฒด๋ผ๊ณ ์๊ฐํ๋ฉด ๋๊ฒ ๋ค
๋ฐ์ดํฐ๋ฅผ ์ด๋ค ๋ฐฉ์์ผ๋ก ์ ๋ฌํ๋๋์ ๋ฐ๋ผ์ 2๊ฐ์ง๋ก ๋๋๋ค
๋ฐ์ดํธ ์คํธ๋ฆผ(Byte Stream)
๋ฐ์ดํฐ๋ฅผ Byte ๋จ์๋ก ์ฃผ๊ณ ๋ฐ๋ ๊ฒ์ ์๋ฏธ
binary ๋ฐ์ดํฐ๋ฅผ ์ ์ถ๋ ฅํ๋ ์คํธ๋ฆผ
์ด๋ฏธ์ง, ๋์์๋ฑ ๋ชจ๋ ์ข ๋ฅ์ ๋ฐ์ดํฐ๋ค์ ์ก์์ ํ ๋ ์ฃผ๋ก ์ฌ์ฉ
๋ํ์ ์ธ ๋ฐ์ดํธ ์คํธ๋ฆผ์๋ ๋ฐ์ดํฐ ์ ๋ ฅ์ InputStream๊ณผ ๋ฐ์ดํฐ ์ถ๋ ฅ์ OutputStream์ด ์๊ณ ์ด ๋ ์ถ์ ํด๋์ค๋ byte๊ธฐ๋ฐ stream์ ์ต๊ณ ์กฐ์์ด๋ค
๋ฌธ์ ์คํธ๋ฆผ (Character Stream)
๋ฌธ์ ๋จ์๋ก ์ธ์ฝ๋ฉ ์ฒ๋ฆฌ๋ฅผ ํ๋ ์คํธ๋ฆผ
ํ ์คํธ ํ์ผ๋ฑ์ ์ก์์ ํ ๋ ์ฃผ๋ก ์ฌ์ฉ
ํ์ง๋ง ์ด ๋ stream์ ๋ชจ๋ ์ฒ์์๋ Byte๋ก ๋ฐ์๋ค์ด๋ ๊ฒ์ ๋์ผํ๋ค. ๊ทธ๋ฆฌ๊ณ ํด๋น Stream์ด ์์์ ์ฒ๋ฆฌ๋ฅผ ํด์ค๋ค.
๋ฒํผ (Buffer)
๋ฒํผ (Buffer)๋ ๋ฐ์ดํฐ๋ฅผ ์ ์กํ๋ ์ํธ ๊ฐ์ ์ฅ์น์์ ๊ณ ์์ ์ฅ์น์ ์ ์์ ์ฅ์น ๊ฐ์ ์๋ ์ฐจ์ด๋ก ์ธํด ์ ์์ ์ฅ์น๊ฐ ์์ ์ ์ถ๋ฆฌํ๋ ๋์, ๊ณ ์์ ์ฅ์น๊ฐ ๊ธฐ๋ค๋ ค์ผํ๋ ํ์์ ์ค์ฌ์ฃผ๋ ๊ธฐ์ ์ด๋ฉฐ ๋ฐ์ดํฐ๋ฅผ ์์ ์ ์ฅํ๋ ๊ณต๊ฐ์ ์๋ฏธํ๋ค. ๊ทธ๋ฆฌ๊ณ ์์์ ์ฅ์ฅ์น๋ก ๋ถ๋ฆฌ์ด๋ค.
๊ทธ๋ฆผ์ผ๋ก ๋ฒํผ๋ฅผ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ์ ์ฌ์ฉํ์ง ์๋ ๊ฒฝ์ฐ๋ฅผ ํ์ธํด๋ดค๋ค

์ด๋ ๊ฒ ๋ฒํผ๋ฅผ ์ฌ์ฉํ๋ฉด, ์ด์์ฒด์ ์ API ํธ์ถ ํ์๋ฅผ ์ค์ฌ์ ์ ์ถ๋ ฅ ์ฑ๋ฅ์ ๊ฐ์ ํ ์ ์๋ค.
(์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ํ๋ Scanner ๋ฐฉ์๊ณผ BufferedReader๋ฐฉ์์ด ์์๋๋ฐ buffer์ ๊ฐ๋ ์ ์ด๋ ๊ฒ ์๊ณ ๋๋๊น ์ ๊ธฐํ๋ค.)
์ฑ๋ (Channel)
์ฑ๋์ ํ ๋ง๋๋ก ์๋ฒ์ ํด๋ผ์ด์ธํธ๊ฐ์ ํต์ ์๋จ์ ๋ํ๋ธ๋ค. ์ฆ ํ ๊ฐ ์ด์์ ํ์คํ ์ ์ถ๋ ฅ ์์ ์ ์ํํ ์ ์๋ ๊ฐ๋ฐฉ๋ ์ฐ๊ฒฐ์ ๋ํ๋ธ๋ค.
์ฑ๋์ ๋น๋๊ธฐ์ ์ผ๋ก ๋ซํ๊ณ ์ค๋จ๋ ์ ์๊ธฐ ๋๋ฌธ์ ํ ์ค๋ ๋๊ฐ ํ ์ฑ๋์ ์ ์ถ๋ ฅ ์์ ์ผ๋ก ๋ธ๋กํ ๋๋ฉด, ๋ค๋ฅธ ์ค๋ ๋๊ฐ ๋ธ๋กํ๋ ์ค๋ ๋๋ฅผ ์ค๋จ์ํฌ ์ ์๋ค. ๊ทธ๋์ ํ์ผ์ ์ถ๋ ฅ์์ ๋ธ๋กํ๋ ์ค๋ ๋๋ฅผ ์ธ์ ๋ ์ค์ง์ํฌ ์ ์์ผ๋ฉฐ, ์ด๋ฅผ ํตํด์ ๋คํธ์ํฌ์์ non-blockin ์ ์ถ๋ ฅ์ด ๊ฐ๋ฅํด์ง
์ฝ, ์ฐ๊ธฐ๋ฅผ ๋์์ ํ ์ ์๋ ๊ฒ์ด ํน์ง์ด๋ฉฐ ์ฑ๋์ ๊ธฐ๋ณธ ์ ์ถ๋ ฅ ๋ฒํผ๋ BtyeBuffer ์ด๊ธฐ ๋๋ฌธ์ ๋ฐ์ดํฐ ํ์ ๋ง๋ ์ ์ฉ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ๊ฐ์ง๊ณ ์๋ค.
InputStream, OutputStream
InputStream์ด๋
์์์๋ ์ธ๊ธํ์ง๋ง ๋ฐ์ดํธ ๊ธฐ๋ฐ์ ์ ๋ ฅ ์คํธ๋ฆผ์ ์ต์์ ํด๋์ค(์ถ์ ํด๋์ค)์ด๋ค. ๊ทธ ์๋ฏธ๋ ๋ชจ๋ ๋ฐ์ดํธ ๊ธฐ๋ฐ ์ ๋ ฅ ์คํธ๋ฆผ์ ์ด ํด๋์ค๋ฅผ ์์๋ฐ์์ ๋ง๋ค์ด์ง๋ค.
InputStream ํด๋์ค์ ๋ฉ์๋๋ค
int available() : ํ์ฌ ์ฝ์ ์ ์๋ ๋ฐ์ดํธ ์๋ฅผ ๋ฐํ
void close() : ํ์ฌ ์ด๋ ค์๋ InputStream์ ๋ซ๋๋ค
void mark(int readlimit) : InputStream์์ ํ์ฌ์ ์์น๋ฅผ ํ์
boolean markSupported() : ํด๋น InputStream์์ mark()๋ก ์ง์ ๋ ์ง์ ์ด ์๋์ง์ ๋ํ ์ฌ๋ถ๋ฅผ ํ์ธ
abstract int read() : InputStream์์ ํ ๋ฐ์ดํธ๋ฅผ ์ฝ์ด์ int ๊ฐ์ผ๋ก ๋ฐํ
int read(byte[] b) : ์ธ์ ๋งํผ์ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ด์ b์ ์ ์ฅํ๊ณ ์ฝ์ ๋ฐ์ดํธ ์ ๋ฐํ
int read(byte b, int off, int len) : len๋งํผ ์ฝ์ด์ b์ off์์น์ ์ ์ฅํ๊ณ ์ฝ์ ๋ฐ์ดํธ ์ ๋ฐํ
void reset() : mark()๋ฅผ ๋ง์ง๋ง์ผ๋ก ํธ์ถํ ์์น๋ก ์ด๋
long skip(long n) : InputStream์์ n๋ฐ์ดํธ ๋งํผ ๋ฐ์ดํฐ๋ฅผ ์คํตํ๊ณ ๋ฐ์ดํธ ์๋ฅผ ๋ฐํ
OutputStream์ด๋
์์์๋ ์ธ๊ธํ์ง๋ง ๋ฐ์ดํธ ๊ธฐ๋ฐ์ ์ ๋ ฅ ์คํธ๋ฆผ์ ์ต์์ ํด๋์ค(์ถ์ ํด๋์ค)์ด๋ค. ๊ทธ ์๋ฏธ๋ ๋ชจ๋ ๋ฐ์ดํธ ๊ธฐ๋ฐ ์ถ๋ ฅ ์คํธ๋ฆผ์ ์ด ํด๋์ค๋ฅผ ์์๋ฐ์์ ๋ง๋ค์ด์ง๋ค.
OutputStream ํด๋์ค์ ๋ฉ์๋๋ค
void close() : OutputStream์ ๋ซ๋๋ค
void flush() : ๋ฒํผ์ ๋จ์์๋ ์ถ๋ ฅ ์คํธ๋ฆผ์ ์ถ๋ ฅ
void write(byte[] b) : ๋ฒํผ์ ๋ด์ฉ์ ์ถ๋ ฅ
void write(byte[] b, int off, int len) : b ๋ฐฐ์ด ์์ ์๋ ์์ off๋ถํฐ len๋งํผ ์ถ๋ ฅ
abstract void write(int b) : ์ ์ b์ ํ์ 1๋ฐ์ดํธ๋ฅผ ์ถ๋ ฅ
ํ์ค ์คํธ๋ฆผ (System.in, System.out, System.err)
System ํด๋์ค๋ ์คํ์๊ฐ ํ๊ฒฝ๊ณผ ๊ด๋ จ๋ ์์ฑ๊ณผ ๋ฉ์๋๋ฅผ ๊ฐ์ง๊ณ ์๋ค.
System ํด๋์ค์์ ์ ๊ณต๋๋ out๊ณผ in์ ์ด์ฉํ ํ์ค ์ ๋ ฅ, ์ถ๋ ฅ, ์๋ฌ ์ถ๋ ฅ์ ๊ดํ ํด๋์ค ๋ณ์, ์ธ๋ถ์ ์ผ๋ก ์ ์๋ ํ๋กํผํฐ ๋ฐ ํ๊ฒฝ ๋ณ์์ ์ ๊ทผ, ํ์ผ ๋ฐ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋ก๋ฉ ๋ฐฉ๋ฒ, ๊ฐ์ฒด๋ฅผ ๋ณต์ฌํด์ฃผ๋ ๋ฉ์๋์ ํ๋ก๊ทธ๋จ์ ์์ฑํ ๋ ์ฌ์ฉํ ์ ์๋ ์ ์ฉํ ๋ฉ์๋
System.in
System.in ์ ๋ณ์ ํ์ ์ด InputStream ํํ๋ก ์ง์ ์ด ๋์ด์๋ค.
์์์ ์ธ๊ธํ์ง๋ง InputStream์ ์ต์์ ํด๋์ค์ด๋ฉด์ ์ถ์ ํด๋์ค์ด๊ธฐ ๋๋ฌธ์ InputStream์ ๊ฐ์ฒด๋ฅผ ์์ฑํ ์ ์๋ ํด๋์ค๋ค
System.in ์ ํตํด์ ์ ๊ทผํ๋ ๊ฐ์ฒด๋ JVM์ด ๋ฉ๋ชจ๋ฆฌ๋ก ์ฌ๋ผ์ค๋ฉด์ ๋ฏธ๋ฆฌ ๊ฐ์ฒด๋ฅผ ์์ฑํด ๋๋ ๋ํ์ ์ธ ๊ฐ์ฒด์ด๋ค. ์๋ฃํ์ด InputStream์ด๊ธฐ ๋๋ฌธ์ ๋ฐ์ดํธ ๋จ์๋ก๋ง ์ ์ถ๋ ฅ๋๋ค.
ํค๋ณด๋์์ ์ ๋ ฅํ๋ ์๋ฃ๋ ๋์ ๋ฐ๋ผ์ ๋ ๋ฐ์ดํธ๊ฐ ํฉ์ณ์ ธ์ผ ์๋ฏธ๋ฅผ ๊ฐ์ง๋ ๊ฒฝ์ฐ๊ฐ ์๋ค. ๊ทธ๋์ System.in์ ํตํด์ ์ฝ์ ๋๋ ์๋ฌธ๊ณผ ํ๊ธ์ ์ฒ๋ฆฌ๋ฅผ ๋ถ๋ฆฌํด์ ๊ตฌ์ฑํด์ผ ์ ์ธ์๋๋ค.
System.out
๊ฐ์ฅ ํํ๊ฒ System.out.println์ผ๋ก ์ฌ์ฉํ๋ฉด์ ๋ณธ ํจ์์ด๋ค
System.out ๋ณ์๋ ํ์ค ์ถ๋ ฅ ์ฅ์น ๊ฐ์ฒด๋ฅผ ๊ฐ๋ฆฌํค๋ ๋ํ์ ์ธ ์ถ๋ ฅ ๋ณ์์ด๋ค.
System.out์ PrintStream ํ์ ์ผ๋ก ๋์ด์๋๋ฐ ์ฌ๊ธฐ์ PrintStream์ด๋ OutputStream ํด๋์ค์ ํ์ ํด๋์ค๋ก Exception์ ์์ ํ๊ฒ ์ฒ๋ฆฌํ ๋ฉ์๋๋ก๋ง ๊ตฌ์ฑ์ด ๋์ด์๋ค. ๊ทธ๋์ ๊ตณ์ด try-catch ๋ฌธ ๊ฐ์ด ๋ฐ๋ก ์ฒ๋ฆฌ๋ฅผ ํด์ฃผ์ง ์์๋ ๊ด์ฐฎ๋ค
System.err
System.err ๊ฐ์ฒด๋ ํ์ค ์๋ฌ ์ถ๋ ฅ ์ฅ์น๋ฅผ ์๋ฏธํ๋ค. ์ค๋ฅ๊ฐ ๋ฐ์ํ๊ฒ ๋๋ฉด System.err๋ก ์๋ ค์ค์ผ ํ๋ ๋ด์ฉ์ด ๋์จ๋ค๊ณ ์๊ฐํ๋ฉด ๋๋ค.
System.err ๋ PrintStream ํด๋์ค ํ์ ์ผ๋ก System.out์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ๊ณผ ๊ฐ๋ค.


ํ์ผ ์ฝ๊ณ ์ฐ๊ธฐ
์๋ฐ์์ ํ์ผ์ ์ฝ๊ณ ์ฐ๋ ๋ฐฉ๋ฒ์ ์๋ฐ์ ๋ด์ฅ ํด๋์ค์ธ FileWriter, BufferedWriter, FileReader, BufferedReader๋ฅผ ์ฌ์ฉํ๋ค
์ฌ๊ธฐ์ ํ์ผ ์ฐ๊ธฐ๋ฅผ ์ํ BufferedWriter์ FileWriter์ ๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ ๋ try-catch์ ๋ง์ง๋ง finally block์์ null check ๋ฐ close()ํ๋ ์ฝ๋๋ฅผ ์ฝ์ ํด ์ค์ผ ํ๋๋ฐ, ์ฌ๊ธฐ์๋ java 7์ ๋์ ๋ try catch with resources์ ์ฌ์ฉํด์ ์งํํด๋ณด์๋ค.
์ด๊ฒ์ try catch block์์ ์์ฑํ ๊ฐ์ฒด๋ฅผ ์๋์ผ๋ก close() ํด์ฃผ๋ ํฅ์๋ try catch๋ฌธ๋ฒ์ด๋ค
import java.io.*;
public class Main{
public static void main(String[] args) {
//ํ์ผ์ ์ฐ๋(์์ผ๋ฉด ์์ฑ)ํ๋ ์ฝ๋
try(
//์ฌ๊ธฐ์ ๊ฐ์ฒด๋ฅผ ์์ฑํ๊ฒ๋๋ฉด try๊ฐ ์ข
๋ฃ๋๊ณ ๋์ ์๋์ผ๋ก close๋๋ค
FileWriter fw = new FileWriter("Testing.txt", true);
BufferedWriter bw = new BufferedWriter(fw);
)
{
//๋ฒํผ์ ๋ฐ์ดํฐ๋ฅผ ๋ฃ๊ณ
bw.write("first Test");
//๋ฒํผ์ ์๋ก์ด ์ค์ ๋ฃ์ด์ฃผ๊ณ
bw.newLine();
bw.write("Second Test");
bw.newLine();
//๋ฒํผ์ ๋ด์ฉ์ ํ์ผ์ ์์ฑ
bw.flush();
}catch(IOException e){
System.out.println(e);
}
File f = new File("Testing.txt");
//ํ์ผ์ด ์กด์ฌํ๊ณ ์๋ ์ง ํ์ธ
if(f.isFile()){
System.out.println("Testing.txt ํ์ผ์ด ์ด๋ฏธ ์กด์ฌํฉ๋๋ค.");
}
//ํ์ผ์ ์ฝ๋ ์ฝ๋
try(
FileReader rw = new FileReader("Testing.txt");
BufferedReader br = new BufferedReader(rw);
){
String readLine = null;
//๋ง์ฝ ์ฝ์๋ผ์ธ์ด ์๋ค๋ฉด null์ ๋ฆฌํดํ๋ค
while((readLine = br.readLine()) != null){
System.out.println(readLine);
}
}catch (IOException e){
System.out.println(e);
}
}
}
์ ์ฝ๋ ์คํ๊ฒฐ๊ณผ

์ค์ ํ์ผ์ด ์์ฑ๋ ๊ฒ๊ณผ ๋ด์ฉ ํ์ธ

์ฐธ๊ณ ์ฌ์ดํธ
https://victorydntmd.tistory.com/134
https://real-dongsoo7.tistory.com/70
https://develop-im.tistory.com/54
https://hyeonstorage.tistory.com/235
https://vmpo.tistory.com/entry/java-try-catch-with-resources-์์ธ์ฒ๋ฆฌ?category=731823
Last updated
Was this helpful?