๋น ๋ฅธ A+B ์ฑ๊ณต
์๊ฐ ์ ํ :1์ด
๋ฌธ์
๋ณธ๊ฒฉ์ ์ผ๋ก for๋ฌธ ๋ฌธ์ ๋ฅผ ํ๊ธฐ ์ ์ ์ฃผ์ํด์ผ ํ ์ ์ด ์๋ค. ์ ์ถ๋ ฅ ๋ฐฉ์์ด ๋๋ฆฌ๋ฉด ์ฌ๋ฌ ์ค์ ์ ๋ ฅ๋ฐ๊ฑฐ๋ ์ถ๋ ฅํ ๋ ์๊ฐ์ด๊ณผ๊ฐ ๋ ์ ์๋ค๋ ์ ์ด๋ค.
Java๋ฅผ ์ฌ์ฉํ๊ณ ์๋ค๋ฉด, Scanner์ System.out.println ๋์ BufferedReader์ BufferedWriter๋ฅผ ์ฌ์ฉํ ์ ์๋ค. BufferedWriter.flush๋ ๋งจ ๋ง์ง๋ง์ ํ ๋ฒ๋ง ํ๋ฉด ๋๋ค.
๋ํ ์ ๋ ฅ๊ณผ ์ถ๋ ฅ ์คํธ๋ฆผ์ ๋ณ๊ฐ์ด๋ฏ๋ก, ํ ์คํธ์ผ์ด์ค๋ฅผ ์ ๋ถ ์ ๋ ฅ๋ฐ์์ ์ ์ฅํ ๋ค ์ ๋ถ ์ถ๋ ฅํ ํ์๋ ์๋ค. ํ ์คํธ์ผ์ด์ค๋ฅผ ํ๋ ๋ฐ์ ๋ค ํ๋ ์ถ๋ ฅํด๋ ๋๋ค.
์ ๋ ฅ
์ฒซ ์ค์ ํ ์คํธ์ผ์ด์ค์ ๊ฐ์ T๊ฐ ์ฃผ์ด์ง๋ค. T๋ ์ต๋ 1,000,000์ด๋ค. ๋ค์ T์ค์๋ ๊ฐ๊ฐ ๋ ์ ์ A์ B๊ฐ ์ฃผ์ด์ง๋ค. A์ B๋ 1 ์ด์, 1,000 ์ดํ์ด๋ค.
์ถ๋ ฅ
๊ฐ ํ ์คํธ์ผ์ด์ค๋ง๋ค A+B๋ฅผ ํ ์ค์ ํ๋์ฉ ์์๋๋ก ์ถ๋ ฅํ๋ค.
public class baekjoon_15552 {
public static void main(String[] args){
int testNum;
int fir;
int sec;
String result;
try {
BufferedReader bufferedReader=new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bufferedWriter= new BufferedWriter(new OutputStreamWriter(System.out));
testNum=Integer.parseInt(bufferedReader.readLine());
for(int i=0; i<testNum;i++) {
StringTokenizer stringTokenizer=new StringTokenizer(bufferedReader.readLine()); //๋์ด์ฐ๊ธฐ๋ฅผ ๊ธฐ์ค์ผ๋ก ๋ถ๋ฆฌ
fir=Integer.parseInt(stringTokenizer.nextToken());
sec=Integer.parseInt(stringTokenizer.nextToken());
result=Integer.toString(fir+sec);
bufferedWriter.write(result);
bufferedWriter.newLine();
}
bufferedReader.close(); //๋ฒํผ ์ด์ฉ์ ์คํธ๋ฆผ์ ๋ซ์์ฃผ์ด์ผ ํ๋ค.
bufferedWriter.flush(); //๋ฒํผ๋ฅผ ๋ซ๊ธฐ ์ ๋ฒํผ ๋ด ๋ฐ์ดํฐ๋ค์ ๋ชจ๋ ๋ด๋ณด๋ด์ผํ๋ค.
//flush ๋ฉ์๋๋ฅผ ๋ง์ง๋ง์ ํ ๋ฒ๋ง ํด์ผ ์๊ฐ ์ด๊ณผx
bufferedWriter.close(); // ๋ฒํผ ์ด์ฉ์ ์คํธ๋ฆผ์ ๋ซ์์ฃผ์ด์ผ ํ๋ค.
}catch(IOException e) {
e.printStackTrace();
System.out.println(e.getMessage());
}
}
}
BufferedReader ์ BufferedWriter
java.IO ํจํค์ง์ ์๋ ํด๋์ค์ด๋ค.
๋ฒํผ๋ฅผ ์ด์ฉํ์ฌ ์ ๋ ฅ๋ฐ์ ๊ฐ๋ค์ ํ ๋ฒ์ ์ ์กํ๊ธฐ ๋๋ฌธ์ ์ ์ถ๋ ฅ์ ํจ์จ์ด ์ข๋ค.
์) ํ์ ์ฝ์ผ๋ก ํ ๋ฒ์ฉ ํ ๋๋ง๋ค ์ฎ๊ธฐ๊ธฐ 10๋ฒ vs ์๋ ์ 10๋ฒ ์ฝ์ผ๋ก ํ์ ํผ ๋ด์ ํ ๋ฒ์ ์ฎ๊ธฐ๊ธฐ
๋ฒํผ(buffer)
์ด๋ค ์ฅ์น์์ ๋ค๋ฅธ ์ฅ์น๋ก ๋ฐ์ดํฐ๋ฅผ ์ก์ ํ ๋ ์ผ์ด๋๋ ์๊ฐ์ ์ฐจ์ด๋ ๋ฐ์ดํฐ ํ๋ฆ์ ์๋ ์ฐจ์ด๋ฅผ ์กฐ์ ํ๊ธฐ ์ํด ์ผ์์ ์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ๊ธฐ์ต์ํค๋ ์ฅ์น.
์ถ์ฒ Oxford Languages
๋ฒํผ๋ง(buffering)
์ด๋ค ์ฅ์น์์ ๋ค๋ฅธ ์ฅ์น๋ก ๋ฐ์ดํฐ๋ฅผ ์ก์ ํ ๋ ์์์ ์๋ ์ฐจ์ด๋ฅผ ์กฐ์ ํ๊ธฐ ์ํด ์ผ์์ ์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ๊ธฐ์ต์ํค๋ ์๋ฒ
1. BufferedReader
๋ณดํต ์๋ฐ์์ ์ ๋ ฅ์ ๋ฐ๊ธฐ ์ํด java.util ํจํค์ง์ Scanner ํด๋์ค์ ์ฌ์ฉํ๋ค. Scanner๊ฐ์ ๊ฒฝ์ฐ ๊ณต๋ฐฑ ๋ฌธ์์ ์ํฐ๋ก ์ ๋ ฅ๊ฐ์ ๊ตฌ๋ถํ๋ค. ์) Scanner.next() / Scanner.nextLine()
์ด์ ๋ค๋ฅด๊ฒ BuferedReader๋ ์ํฐ๋ง ๊ฒฝ๊ณ๋ก ์ธ์ํ๋ค. ๋ฐ๋ผ์ ๊ณต๋ฐฑ ๋ฌธ์๋ก ์ ๋ ฅ๊ฐ์ ๊ตฌ๋ถํ๊ธฐ ์ํด์๋ ๋ฐ๋ก ์ฒ๋ฆฌ๊ฐ ํ์ํ๋ค. (์ฌ๊ธฐ์๋ StringTokenizer๋ฅผ ์ฌ์ฉํ ์์ ์ด๋ค.)
Reads text from a character-input stream, buffering characters so as to * provide for the efficient reading of characters, arrays, and lines. * *
: ๋ฌธ์๋ค, ๋ฐฐ์ด, ์ค์ ํจ์จ์ ์ธ ์ฝ๊ธฐ๋ฅผ ์ ๊ณตํ๊ธฐ ์ํด์ ๋ฌธ์๋ค์ ๋ฒํผ๋งํ๋ฉด์ ๋ฌธ์ ์ ๋ ฅ ์คํธ๋ฆผ์ผ๋ก๋ถํฐ ๊ธ์๋ฅผ ์ฝ๋๋ค.
<p> The buffer size may be specified, or the default size may be used. The * default is large enough for most purposes. * *
: ๋ฒํผ ํฌ๊ธฐ๋ ์ ํ ์๋, ๊ธฐ๋ณธ ํฌ๊ธฐ๋ฅผ ์ฌ์ฉํ ์๋ ์๋ค. ๊ธฐ๋ณธ ํฌ๊ธฐ๋ ์ถฉ๋ถํ ํฌ๋ค
<p> In general, each read request made of a Reader causes a corresponding * read request to be made of the underlying character or byte stream.
:์ผ๋ฐ์ ์ผ๋ก, Reader์ ๊ฐ ์ฝ๊ธฐ ์์ฒญ์ ํ๊ท ์ดํ์ ๋ฌธ์, byte ์คํธ๋ฆผ์ผ๋ก ๊ตฌ์ฑ๋ ํด๋น ์ฝ๊ธฐ์์ฒญ์ ์ผ๊ธฐ์ํจ๋ค.
It is * therefore advisable to wrap a BufferedReader around any Reader whose read() * operations may be costly, such as FileReaders and InputStreamReaders.
:๋ฐ๋ผ์ BufferedReader๋ก FileReader์ InputStreamReader๊ฐ์ด read()์์ ์ ๋น์ฉ์ด ๋ง์ด ๋ค ์ ์๋ ๋ค๋ฅธ Reader๋ฅผ ๊ฐ์ธ๋ ๊ฒ์ด ์ข๋ค.
For * example, * * <pre> * BufferedReader in * = new BufferedReader(new FileReader("foo.in")); * </pre> * * will buffer the input from the specified file. Without buffering, each * invocation of read() or readLine() could cause bytes to be read from the * file, converted into characters, and then returned, which can be very * inefficient. * * <p> Programs that use DataInputStreams for textual input can be localized by * replacing each DataInputStream with an appropriate BufferedReader. * * @see FileReader * @see InputStreamReader * @see java.nio.file.Files#newBufferedReader * * @author Mark Reinhold * @since 1.1
BufferedReader์ ์ฌ์ฉ๋ฒ
import java.io.BufferedReader; //BufferedReader๋ java.ioํจํค์ง
class Test{
public static void main(String[] args) throws IOException{
//BufferedReader ์ฌ์ฉ ์ ์์ธ์ฒ๋ฆฌ ํ์.
// try-catch ๊ตฌ๋ฌธ ์ฌ์ฉ ๊ฐ๋ฅ
BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
int intNum=Integer.parseInt(bfr.readLine());
//BufferedReader.readLine()์ ๋ฌธ์์ด์ ๋ฐํํด์ฃผ๊ธฐ ๋๋ฌธ์
//int๊ฐ์ ๋ฐ๊ธฐ ์ํด์๋ ํ๋ณํ์ด ํ์ํ๋ค.
//๋์ด์ฐ๊ธฐ๋ฅผ ๊ธฐ์ค์ผ๋ก ์
๋ ฅ๊ฐ ๋ฐ๊ธฐ
StringTokenizer stz=new StringTokenizer(bfr.readLine());//๋์ด์ฐ๊ธฐ๋ฅผ ๊ธฐ์ค์ผ๋ก ํ ํฐํ
String str1 = stz.nextToken();
String str2= stz.nextToken();
์)
์
๋ ฅ: this is a test
str1 -> this
str2 -> is
bfr.close() //๋ฒํผ ์ด์ฉ์ ์ฌ์ฉ์ด ๋๋ ํ ๋ฐ๋์ ์คํธ๋ฆผ์ ๋ซ์์ฃผ์ด์ผ ํ๋ค.
}
}
๋ฉ์๋ ์ข ๋ฅ
๋ฉ์๋ ๋ช | ์ค๋ช |
BufferedReader(Reader in[, int size]) | Creates a buffering character-input stream that uses an input buffer of * the specified size. size ํฌ๊ธฐ์ ์ ๋ ฅ ๋ฒํผ๋ฅผ ์ฌ์ฉํ๋ ๋ฌธ์ ์ ๋ ฅ ๋ฒํผ์คํธ๋ฆผ์ ์์ฑํ๋ค. - size ํ๋ผ๋ฏธํฐ ์๋ต ์ defualt ํฌ๊ธฐ์ ๋ฌธ์ ์ ๋ ฅ ๋ฒํผ์คํธ๋ฆผ ์์ฑ |
int read([char cbuf[][, int off, int len]]) | ๋ฌธ์ ๋ฐฐ์ด cbuf์ off ์์น์์ ๋ถํฐ len ๊ฐ์ ๋ฌธ์๋ฅผ ํ ๋ฌธ์์ฉ ์ฝ์ด ์ซ์๋ก ๋ฐํํ๋ค. ์ฆ, ํด๋น ๋ฌธ์์ ์์คํค ์ฝ๋ ๊ฐ ๋ฐํํ๋ค. ๋ง์ฝ ์คํธ๋ฆผ์ ๋์ ๋๋ฌํ๋ฉด -1์ ๋ฐํํ๋ค. -read() :Reads a single character. ํ ๊ฐ์ ๋ฌธ์๋ฅผ ์ฝ๋๋ค. -read(char cbuf[]) |
String readLine() | Reads a line of text. '\n'์ ๊ธฐ์ค์ผ๋ก, ํ ์ค์ ๊ธ์ ์ฝ๊ณ ๋ฌธ์์ด์ ๋ฐํํ๋ค. |
long skip(long n) | Skips characters. n ๊ฐ์๋งํผ ๋ฌธ์๋ฅผ ๊ฑด๋๋ฐ๊ณ ๊ฑด๋๋ด ๋ฌธ์์ ๊ฐ์๋ฅผ ๋ฐํํ๋ค. |
boolean ready() | Tells whether this stream is ready to be read. ํด๋น ์คํธ๋ฆผ์ด ์ฌ์ฉํ ์ค๋น๊ฐ ๋์๋์ง ์๋์ง ์๋ ค์ค๋ค. |
boolean markSupported() | Tells whether this stream supports the mark() operation, which it does. ํด๋น ์คํธ๋ฆผ์ด mark() ๊ธฐ๋ฅ์ ์ง์ํ๋์ง ์๋์ง ์๋ ค์ค๋ค. |
void mark(int readAheadLimit) | Marks the present position in the stream. ์คํธ๋ฆผ์์ ํ์ฌ ์์น๋ฅผ ๋งํนํ๋ค. |
void reset() | Resets the stream to the most recent mark. ๊ฐ์ฅ ์ต๊ทผ ๋งํน์ผ๋ก ์คํธ๋ฆผ์ ์ฌ์ค์ ํ๋ค. |
void close() | ์คํธ๋ฆผ์ ๋ซ์์ค๋ค. |
๊ณต๋ถ์ ์ฐธ๊ณ ํ ์๋ฃ
https://jhnyang.tistory.com/92
https://coding-factory.tistory.com/251
https://medium.com/@isaacjumba/why-use-bufferedreader-and-bufferedwriter-classses-in-java-39074ee1a966
์๋ฐ ๊ณต์ ๋ฌธ์
BufferedReader , BufferedWriter
https://jhnyang.tistory.com/398
์๋ฐ๊ณต์ ๋ฌธ์
StringTokenizer
'์ฝ๋ฉ ํ ์คํธ > ๋ฐฑ์ค ์๊ณ ๋ฆฌ์ฆ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ ๋ฐฑ์ค ์๊ณ ๋ฆฌ์ฆ / java ] 10828 - ์คํ (1) (0) | 2021.06.24 |
---|---|
[ ๋ฐฑ์ค ์๊ณ ๋ฆฌ์ฆ / Java ] 1152 - ๋จ์ด์ ๊ฐ์ (0) | 2021.06.20 |