์ฝ๋ฉํ ์คํธ์์ ํจ์๋ฅผ ๊ตฌํํ๋ผ๊ณ ์ง์๋ฐ์ ๋๋ ๋ง์ง๋ง, ์ง์ ์ฃผ์ด์ง ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅํ์ฌ ๋ฌธ์ ์์ ์ง์ ๋ ํํ์ ๊ฐ์ ์ถ๋ ฅํ๋ผ๊ณ ์๊ตฌ๋ฐ๋ ๋๋ ๋ง๋ค. ๊ฐ์ธ์ ์ผ๋ก Scanner์ readline ํจ์๋ฅผ ํตํด ๋ฏธ๋ ๊ณผ์ ๋ฅผ ์ ๋ถ ํด๊ฒฐํ์ฌ, ์ฝ๋ฉํ ์คํธ์์๋ ์ด๋ฅผ ์ฒ์์ ์ฌ์ฉํ์์ง๋ง, ๋ ์์ ์ํ์๊ฐ์ ๊ฐ์ง ์ฝ๋๋ค์ Scanner๊ฐ ์๋ InputStreamReader๋ฅผ ํตํด ๋๋ต ์ด๋ฐ์์ผ๋ก ์ธํ์ ๋ฐ๋ ๊ฒ์ ํ์ธํ๋ค:
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int someInput = Integer.parseInt(br.readLine());
๊ทธ ๋ค๋ก๋ ๋งค๋ฒ ์ด๋ ๊ฒ ์ ๋ ฅ์ ์ฒ๋ฆฌํ์ง๋ง, ์ค์ ๋ก ๋ฌด์์ด ๋ค๋ฅธ์ง ๋ชฐ๋๊ธฐ์, ์ด ๋ฌธ์์์ ํด๋น ๋ถ๋ถ์ ์์๋ณธ๋ค.
์ ์ถ๋ ฅ์ด๋ ์ปดํจํฐ ๋ด์ธ๋ถ ์ฅ์น์ ํ๋ก๊ทธ๋จ๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ์ฃผ๊ณ ๋ฐ๋ ์ผ์ด๊ณ , Stream ์ด๋ ์ด ๊ณผ์ ์์ ๋ ๋์์ ์ฐ๊ฒฐํ๊ณ , ๋ฐ์ดํฐ๋ฅผ ์ ์กํ๋ ํต๋ก์ด๋ค.
์ฃผ์ ํน์ง์ ์๋์ ๊ฐ๋ค :
๋ชจ๋ ๋ฐ์ดํธ ๊ธฐ๋ฐ ์คํธ๋ฆผ์ InputStream ๊ณผ OutputStream ์ ์์์ด๋ฉฐ ์ ์ถ๋ ฅ ๋์์ ์ข ๋ฅ์ ๋ฐ๋ผ ํ์๋์๋ค. ์๋ก ๋ค์ด, ํ์ผ์ ๋ํด ์ ์ถ๋ ฅ์ ํ๋ Stream Class ๋ FileInputStream, FileOutputStream ์ด๋ค. ์ด์ฒ๋ผ ์ฌ๋ฌ ์ข ๋ฅ์ I/O Stream ์ด ์กด์ฌํ์ง๋ง, ์ ์ถ๋ ฅ์ ๊ดํ ์ฃผ์ ๋ฉ์๋๋ค์ ์กฐ์์ธ InputStream, OutputStream ์ ์ถ์ ๋ฉ์๋๋ค์ override ํ์ฌ ๊ตฌํํ์๊ธฐ ๋๋ฌธ์ ๋คํ์ค๋ฝ๊ฒ๋ ํ๋ก๊ทธ๋๋ฐ์ ํ๊ธฐ์ ํธ๋ฆฌํ๋ค.
abstract int read(); // why int not byte ? ์ฝ์์ ์์์ -1 ๋ก ํํํ๊ธฐ ๋๋ฌธ
abstract void write(byte[] b);
int read(byte[] b, int off, int len);
void write(byte[] b , int off, int len);
์ฃผ์ ๋ฉ์๋๋ค์ ์กฐ๊ธ ์ดํด๋ณด๋ฉด,
int available()
: ์คํธ๋ฆผ์ผ๋ก๋ถํฐ ๋ธ๋ฝํน (blocking) ์์ด ์ฝ์ด์ฌ ์ ์๋ ๋ฐ์ดํฐ์ ํฌ๊ธฐvoid mark(int readlimit)
: ํ์ฌ ์์น ํ์, reset์ ์ํด ๋์๊ฐ ์ ์๋ค. markSupported() == true์ผ ๋๋ง ์ฌ์ฉ ๊ฐ๋ฅ. mark ๋ก ๋ถํฐ readlimit ๋ณด๋ค ๋ ์ฝ์ด ๋ค์ด๋ฉด save Xlong skip(long n)
: n ๋งํผ skipํ๋ค. void flush()
: ์คํธ๋ฆผ ๋ฒํผ์ ์๋ ๋ชจ๋ ๋ด์ฉ์ ์ถ๋ ฅ์ ์ด๋ค void close()
: ์คํธ๋ฆผ์ ๋ซ๊ณ , ์ฌ์ฉํ๊ณ ์๋ ์์์ ๋ฐํํ๋ค. ๋ณด์กฐ ์คํธ๋ฆผ์ ์ค์ ๋ฐ์ดํฐ๋ฅผ ์ฃผ๊ณ ๋ฐ๋ ๊ฒ์ ์ฌ์ฉ๋์ง ์๊ณ , ๊ธฐ๋ณธ ์คํธ๋ฆผ์ ๊ธฐ๋ฅ์ ํฅ์์ํค๊ฑฐ๋ ์ถ๊ฐํ ๋ ์ฐ์ธ๋ค. ๋ฐ๋ผ์, ์คํธ๋ฆผ์ ๋จผ์ ์์ฑํ ์ดํ ๋ณด์กฐ์คํธ๋ฆผ์ ์์ฑํ๋ค. ์๋ก ๋ค์ด, ์๊น File์ ๋ํ ์ ์ถ๋ ฅ์ FileInput/OutputStream ์์ ์ฒ๋ฆฌํ ์ ์๋ค๊ณ ํ๋๋ฐ, ์ ๋ ฅ ์ฑ๋ฅ์ ํฅ์์ํค๊ธฐ ์ํด์ BufferedInputStream์ ์ฌ์ฉํ ์ ์๋ค.
์ด๋ฆ์์ ์ ์ ์๋ฏ์ด, FileInputStream์ read()๋ 1 byte ์ฉ ํ์ผ์์ ์ฝ์ด์ค๋ ๋ฐ๋ฉด, BufferedInputStream ์ ๋ด๋ถ์ ์ผ๋ก Buffer array ๋ฅผ ์์ฑํด ํ์ํ ๋ฐ์ดํฐ๋ฅผ ํด๋น ๋ฒํผ์์ ์ฝ์ด์ค๊ณ , File ์์ ํ์ํ ๋ถ๋ถ๋งํผ Buffer๋ฅผ ๋ค์ ์ฑ์ด๋ค. ๋ง์ฝ ํ ํ์ผ์์ 256 Byte๋ฅผ ์ฝ์ด์์ผํ๋ค๋ฉด, FileInputStream์ ํด๋น File ์ ์ ๋ถ ์ฝ์ด๋ค์ด๊ธฐ ์ํด 256๋ฒ read call ์ ๋ง๋ค ๊ฒ์ด์ง๋ง, BufferedReader๋ ํ๋ฒ์ ๋ ๋ง์ด ์ฝ์ด ๋ค์ฌ 1-2๋ฒ์ call ๋ก ํด๊ฒฐํ๋ค. ๋ณดํต ํ์ผ์ ๊ฒฝ์ฐ 8K์ ๋์ ํฌ๊ธฐ๋ก ๋ฒํผ๋ฅผ ์ค์ ํ๋ค๊ณ ํ๋ค.
์กฐ๊ธ ์ฃผ์ํด์ผ ํ ์ ์, ์ถ๋ ฅ์ ๊ฒฝ์ฐ, ๋ฒํผ๊ฐ ๊ฐ๋ ์ฐผ์ ๋๋ง ์ถ๋ ฅ ์์ค์ ์ถ๋ ฅ์ ํ๊ธฐ ๋๋ฌธ์, ๋ง์ง๋ง ๋ถ๋ถ์ด ๋ฒํผ์ ๋จ์ ์๋ ์ฑ๋ก ํ๋ก๊ทธ๋จ์ด ์ข ๋ฃ ๋ ์ ์๋ค. ์ด ๋๋ ๋ชจ๋ ์ถ๋ ฅ ๋ ์ ์๋๋ก close ๋ flush ํจ์๋ฅผ ์จ์ฃผ๋๋ก ํ์.
์ค์ ๋ก ์ผ๋ง๋ ์ฐจ์ด๊ฐ ๋๋์ง ์คํ์ ํด๋ณด์๋ค. ์ฝ 8693 KB ์ ํ์ผ์ ์ฝ์ด๋ค์ด๋ ๋ฐ ๊ฑธ๋ฆฌ๋ ์๋๋ฅผ ์ธก์ ํ ๊ฒ์ด์๋๋ฐ, ๊ฒฐ๊ณผ๋ ์ถฉ๊ฒฉ์ ์ด์๋ค. FileInputSystem์ผ๋ก๋ ์ฝ 26ms์ ์๊ฐ์ด ๊ฑธ๋ ธ์ง๋ง, BufferedInputSystem์ผ๋ก๋ 0.00005ms ๋ฏธ๋ง์ด ๊ฑธ๋ ธ๋ค..!
import java.io.*;
public class Main {
public static void main(String[] args) throws FileNotFoundException {
long beforeTime = System.currentTimeMillis();
FileInputStream fis = null;
try {
// 8683 KB ํ์ผ ํ
์คํธ
File file = new File("D:\\test.txt");
fis = new FileInputStream(file);
// BufferedInputStream bis = new BufferedInputStream(fis);
int i = 0;
while ((i = bis.read()) != -1) {
System.out.write(i);
}
} catch (IOException e) {
System.out.println(e);
} finally {
try {
fis.close();
} catch (IOException io) {
}
long afterTime = System.currentTimeMillis();
long secDiffTime = (afterTime - beforeTime) / 1000;
System.out.println("์๊ฐ์ฐจ์ด(m) : " + secDiffTime);
}
}
}
์์์ ํ ์คํธํ BufferedInputStream ์ธ์๋ ์๋์ ๊ฐ์ ๋์์ด ๋๋ ๋ณด์กฐ ์คํธ๋ฆผ์ด ์์ผ๋, ์์๋๋ฉด ์ฝ๋ ์ฑ๋ฅ ํฅ์๋ ๋๊ณ ํธ๋ฆฌ์ฑ๋ ๊ฐ์ถ์ด ์ข์ ๊ฒ ๊ฐ๋ค:
charํ์ด 1๋ฐ์ดํธ๊ฐ ์๋ 2๋ฐ์ดํธ์ด๊ธฐ ๋๋ฌธ์ ๊ธฐ์กด์ ์ธ๊ธํ ๋ฐ์ดํธ ๊ธฐ๋ฐ์ผ๋ก๋ ๋ฌธ์๋ฅผ ์ฒ๋ฆฌํ๋ ๋ฐ์ ์ด๋ ค์์ด ์๋ค. ์ด๋ด ๋๋ ๋ฐ์ดํธ๊ธฐ๋ฐ ์คํธ๋ฆผ์ ์ฐ์ง๋ง๊ณ , ๋ฌธ์ ๊ธฐ๋ฐ ์คํธ๋ฆผ์ ์ฐ์. InputStream/ OutputStream ๋์ ์ Reader/Writer suffix ๋ฅผ ๊ฐ์ง๊ณ ์๋ค. ์ค์ ์ถ์ ๋ฉ์๋ read / write๋ฅผ ๋จผ์ ์ดํด๋ณด๋ฉด, ์๋๊ฐ์ ์ฐจ์ด๊ฐ ์๋ค.
abstract int read(char[] cbuf, int off, int len)
void write(char[] cbuf)
๊ทธ๋ฆฌ๊ณ ๋จ์ํ 2 byte๋ก ์ ์ถ๋ ฅ์ ํ๋ ๊ฒ์์ ๋๋์ง ์๊ณ , ์ฌ๋ฌ ์ข ๋ฅ์ ์ธ์ฝ๋ฉ๊ณผ ์๋ฐ์์ ์ฌ์ฉํ๋ ์ ๋์ฝ๋๊ฐ์ ๋ณํ์ ์๋์ผ๋ก ์ฒ๋ฆฌํด์ค๋ค. ์ง์ ๋ ์ธ์ฝ๋ฉ์ ์ฌ์ฉํ๋ Reader๋ฅผ ์์ฑํ ์๋ ์๊ณ , ํ์ฌ ์ธ์ฝ๋ฉ์ ์๋ ค์ฃผ๊ธฐ๋ ํ๋ค. ์๋ ์์ ์ฝ๋์ ์ถ๋ ฅ์ ์ดํด๋ณด๋ฉด,
import java.io.*;
public class Main {
public static void main(String[] args) throws FileNotFoundException {
try
{
FileInputStream fis = new FileInputStream("D:\\test.txt");
FileReader fr = new FileReader("D:\\test.txt");
int data = 0;
while( (data = fis.read()) != -1) {
System.out.print((char) data);
}
fis.close();
System.out.println();
while((data = fr.read())!= -1)
{
System.out.print((char)data);
}
fr.close();
}catch (IOException e)
{
e.printStackTrace();
}
}
}
์ถ๋ ฅ :
รฏยปยฟรฌยยดรชยฒยรฌยย รญย
ยรฌยยครญยยธ
๏ปฟ์ด๊ฒ์ ํ
์คํธ
์ด๋ ๊ฒ ๊ธฐ๋ณธ FileInputStream์ ์ฌ์ฉํ์ ๋๋ ํ๊ธ์ด ๊นจ์ ธ์ ๋์ค๋๊ฑธ ์ ์ ์๋ค. ๋ค๋ง, ์ด๋ฏธ์ง์ ์ฌ์ด๋ ๊ฐ์ ๋ฐ์ด๋๋ฆฌ ํ์ผ๋ค์ ์ฒ๋ฆฌํ ๋ ์ฌ์ฉํ๋ฉด ์ ๋๋ก ๋์ง ์์ผ๋, ์ฐ์์๋ฅผ ๊ผญ ํ์ ํ๊ณ ์ ์ ํ Stream ์ ์ฐ๋๋ก ํ์.
๋ฒํผ๋ฅผ ์ฌ์ฉํ์ฌ ์ ์ถ๋ ฅ์ ํจ์จ์ ๋๋ฆฌ๋ ๋ฌธ์๊ธฐ๋ฐ์ ๋ณด์กฐ ์คํธ๋ฆผ์ด๋ผ๊ณ ํ ์ ์๊ฒ ๋ค.
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int someInput = Integer.parseInt(br.readLine());
๊ทธ๋ฆฌ๊ณ Scanner๋ณด๋ค ๋นจ๋๋ ์ด์ ๋ Buffer ํฌ๊ธฐ ์ฌ์ด์ฆ ๋๋ฌธ์ด๋ค. Scanner ๋ 1KB ํฌ๊ธฐ์ ๋ฒํผ๋ฅผ ๊ฐ์ง๋ง, BufferedReader๋ ๊ทธ๊ฒ๋ณด๋ค ํฐ ๋ฒํผ๋ฅผ ๊ฐ์ ธ, ํ๋ฒ์ ์ ์กํ๊ธฐ ๋๋ฌธ์ ๋น ๋ฅด๋ค. ์ถ๊ฐ์ ์ผ๋ก๋, Scanner๋ Parsing ๊ณผ์ ์ ๊ฑฐ์น๊ธฐ ๋๋ฌธ์ ํธ๋ฆฌํ ๋ถ๋ถ์ด ๋ถ๋ช ์์ง๋ง ์๊ฐ์ด ์์๋๊ธฐ ๋๋ฌธ์ ํ๊ท ์ฝ 8๋ฐฐ ์ ๋ ์ ์ถ๋ ฅ์ ๋ํด BufferedReader ๊ฐ ๋น ๋ฅด๋ค.
์ด์ ๋๋จธ์ง ๋ถ๋ถ์ System. in ์ด ๋ถ๋ถ์ธ๋ฐ, ํ์ค ์ ์ถ๋ ฅ ์์คํ (Standard I/O)์ด๋ค. ๋ฐ๋ก ์์ฑํ์ง ์์๋, ์๋ฐ ํ๋ก๊ทธ๋จ์ ์คํํ๋ฉด ์๋์ผ๋ก 3๊ฐ์ง, in, out, err ๊ฐ ์์ฑ๋์ด ์ ๊ณต๋๋ค. ๋ด๋ถ๋ฅผ ์กฐ๊ธ ๋ ์ดํด๋ณด๋ฉด, ์ด๋ ๊ฒ ์ ์ธ๋์ด ์๋ค :
public final static InputStream in = null;
public final static PrintStream out = null;
public final static PrintStream err = null;
in, out, err ๋ System ํด๋์ค์ ์ ์ธ๋ static ๋ณ์์ด๋ฉฐ, ํ์ ์ InputStream/PrintStream์ด์ง๋ง ์ค์ ๋ก๋ BufferedInputStream/BufferedPrintStream์ ์ธ์คํด์ค๋ก ์ฌ์ฉ๋๋ค. ๋ฌผ๋ก , setIn(), setOut(), setErr() ๋ฑ์ ํจ์๋ฅผ ์ด์ฉํด ์ฝ์ ์ด์ธ์ ๋ค๋ฅธ ์ ์ถ๋ ฅ ๋์์ผ๋ก ๋ณ๊ฒฝํ ์ ์๋ค.