1. OutputStreamํด๋ž˜์Šค

์šฐ๋ฆฌ๋Š” ์ตœ๊ทผ์— ์ž…๋ ฅ ์ŠคํŠธ๋ฆผ์„ ํƒ์ƒ‰ํ–ˆ์Šต๋‹ˆ๋‹ค. ์ด์ œ ์ถœ๋ ฅ ์ŠคํŠธ๋ฆผ์— ๋Œ€ํ•ด ์ด์•ผ๊ธฐํ•  ์‹œ๊ฐ„์ž…๋‹ˆ๋‹ค.

์ด OutputStreamํด๋ž˜์Šค๋Š” ๋ฐ”์ดํŠธ ์ถœ๋ ฅ์„ ์ง€์›ํ•˜๋Š” ๋ชจ๋“  ํด๋ž˜์Šค์˜ ์ƒ์œ„ ํด๋ž˜์Šค์ž…๋‹ˆ๋‹ค. ์ด๊ฒƒ์€ ์ž์ฒด์ ์œผ๋กœ๋Š” ์•„๋ฌด ๊ฒƒ๋„ ์ˆ˜ํ–‰ํ•˜์ง€ ์•Š๋Š” ์ถ”์ƒ ํด๋ž˜์Šค์ด์ง€๋งŒ ๋ชจ๋“  ๊ฒฝ์šฐ์— ๋Œ€ํ•œ ํ•˜์œ„ ํด๋ž˜์Šค๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค.

๋งค์šฐ ๋ณต์žกํ•˜๊ฒŒ ๋“ค๋ฆฝ๋‹ˆ๋‹ค. ๊ฐ„๋‹จํžˆ ๋งํ•ด์„œ ์ด ํด๋ž˜์Šค๋Š” ์˜ˆ๋ฅผ ๋“ค์–ด ๋ฌธ์ž๋‚˜ ๋‹ค๋ฅธ ๋ฐ์ดํ„ฐ ์œ ํ˜•์ด ์•„๋‹Œ ๋ฐ”์ดํŠธ์—์„œ ์ž‘๋™ํ•ฉ๋‹ˆ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ๊ทธ๊ฒƒ์ด ์ถ”์ƒ์ ์ด๋ผ๋Š” ์‚ฌ์‹ค์€ ์šฐ๋ฆฌ๊ฐ€ ์ผ๋ฐ˜์ ์œผ๋กœ ๊ทธ๊ฒƒ์„ ์‚ฌ์šฉํ•˜์ง€ ์•Š๊ณ  ๊ทธ ์ž์† ํด๋ž˜์Šค ์ค‘ ํ•˜๋‚˜๋ฅผ ์‚ฌ์šฉํ•œ๋‹ค๋Š” ๊ฒƒ์„ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด, FileOutputStream๋“ฑ๋“ฑ.

๊ทธ๋Ÿฌ๋‚˜ OutputStream์ˆ˜์—…์œผ๋กœ ๋Œ์•„๊ฐ‘๋‹ˆ๋‹ค. ์ด ํด๋ž˜์Šค์—๋Š” ๋ชจ๋“  ์ž์† ํด๋ž˜์Šค๊ฐ€ ๊ตฌํ˜„ํ•ด์•ผ ํ•˜๋Š” ๋ฉ”์„œ๋“œ๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค. ์ฃผ์š” ๋‚ด์šฉ์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

ํ–‰๋™ ์–‘์‹ ์„ค๋ช…
void write(int b)
int์ŠคํŠธ๋ฆผ์— 1๋ฐ”์ดํŠธ( ๊ฐ€ ์•„๋‹˜)๋ฅผ ์”๋‹ˆ๋‹ค .
void write(byte[] buffer)
์ŠคํŠธ๋ฆผ์— ๋ฐ”์ดํŠธ ๋ฐฐ์—ด์„ ์”๋‹ˆ๋‹ค.
void write(byte[] buffer, off, len)
๋ฐ”์ดํŠธ ๋ฐฐ์—ด์˜ ์ผ๋ถ€๋ฅผ ์ŠคํŠธ๋ฆผ์— ์”๋‹ˆ๋‹ค.
void flush()
๋ฒ„ํผ์— ์ €์žฅ๋œ ๋ชจ๋“  ๋ฐ์ดํ„ฐ๋ฅผ ์ŠคํŠธ๋ฆผ์— ์”๋‹ˆ๋‹ค.
void close()
์ŠคํŠธ๋ฆผ์„ ๋‹ซ์Šต๋‹ˆ๋‹ค

๋ฅผ ์ƒ์†ํ•˜๋Š” ํด๋ž˜์Šค์˜ ๊ฐœ์ฒด๋ฅผ ๋งŒ๋“ค ๋•Œ InputStream์ผ๋ฐ˜์ ์œผ๋กœ ๋ฐ์ดํ„ฐ๋ฅผ ์ฝ๋Š” ์†Œ์Šค ๊ฐœ์ฒด๋ฅผ ์ง€์ •ํ•ฉ๋‹ˆ๋‹ค InputStream. ๋ฅผ ์ƒ์†ํ•˜๋Š” ํด๋ž˜์Šค์˜ ๊ฐœ์ฒด๋ฅผ ๋งŒ๋“ค ๋•Œ OutputStream์ผ๋ฐ˜์ ์œผ๋กœ ๋ฐ์ดํ„ฐ๊ฐ€ ๊ธฐ๋ก๋  ๋Œ€์ƒ ๊ฐœ์ฒด ๋˜๋Š” ์ŠคํŠธ๋ฆผ๋„ ์ง€์ •ํ•ฉ๋‹ˆ๋‹ค.

ํด๋ž˜์Šค์˜ ๋ชจ๋“  ๋ฉ”์„œ๋“œ๋ฅผ ๊ฐ„๋‹จํžˆ ์‚ดํŽด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค OutputStream.

write(int b)๋ฐฉ๋ฒ•

int์ด ๋ฉ”์„œ๋“œ๋Š” ์ถœ๋ ฅ ์ŠคํŠธ๋ฆผ์— 1๋ฐ”์ดํŠธ( ๊ฐ€ ์•„๋‹˜)๋ฅผ ์”๋‹ˆ๋‹ค . ์ „๋‹ฌ๋œ ๊ฐ’์€ ๋ฐ”์ดํŠธ๋กœ ์บ์ŠคํŒ…๋˜๊ณ  int์˜ ์ฒ˜์Œ ์„ธ ๋ฐ”์ดํŠธ๋Š” ๋ฒ„๋ ค์ง‘๋‹ˆ๋‹ค.

write(byte[] buffer)๋ฐฉ๋ฒ•

์ง€์ •๋œ ๋ฐ”์ดํŠธ ๋ฐฐ์—ด์„ ์ถœ๋ ฅ ์ŠคํŠธ๋ฆผ์— ์”๋‹ˆ๋‹ค. ๊ทธ๊ฒŒ ๋‹ค์•ผ.

write(byte[] buffer, int offset, int length)๋ฐฉ๋ฒ•

์ „๋‹ฌ๋œ ๋ฐ”์ดํŠธ ๋ฐฐ์—ด์˜ ์ผ๋ถ€๋ฅผ ์ถœ๋ ฅ ์ŠคํŠธ๋ฆผ์— ์”๋‹ˆ๋‹ค. ์˜คํ”„์…‹ ๋ณ€์ˆ˜๋Š” ๋ฐฐ์—ด์˜ ์ฒซ ๋ฒˆ์งธ ์š”์†Œ์˜ ์ธ๋ฑ์Šค๋ฅผ ๋‚˜ํƒ€๋‚ด๋ฉฐ length๊ธฐ๋กํ•  ๋ถ€๋ถ„ ์ง‘ํ•ฉ์˜ ๊ธธ์ด์ž…๋‹ˆ๋‹ค.

flush()๋ฐฉ๋ฒ•

์ด flush()๋ฉ”์„œ๋“œ๋Š” ํ˜„์žฌ ์ŠคํŠธ๋ฆผ์— ์ž ์žฌ์ ์œผ๋กœ ๋ฒ„ํผ๋ง๋œ ๋ชจ๋“  ๋ฐ์ดํ„ฐ๋ฅผ ๋Œ€์ƒ ์ŠคํŠธ๋ฆผ์— ๊ธฐ๋กํ•˜๋Š” ๋ฐ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค. ์ด๋Š” ๋ฒ„ํผ๋ง ๋ฐ/๋˜๋Š” ์ฒด์ธ์— ๋ฐฐ์—ด๋œ ์—ฌ๋Ÿฌ ์ŠคํŠธ๋ฆผ ๊ฐœ์ฒด๋ฅผ ์‚ฌ์šฉํ•  ๋•Œ ๊ด€๋ จ์ด ์žˆ์Šต๋‹ˆ๋‹ค.

close()๋ฐฉ๋ฒ•

๊ธฐ๋ก๋˜์ง€ ์•Š์€ ๋ชจ๋“  ๋ฐ์ดํ„ฐ๋ฅผ ๋Œ€์ƒ ๊ฐœ์ฒด์— ์”๋‹ˆ๋‹ค. close()๋ธ”๋ก ์„ ์‚ฌ์šฉํ•˜๋Š” ๊ฒฝ์šฐ ๋ฉ”์„œ๋“œ๋ฅผ ํ˜ธ์ถœํ•  ํ•„์š”๊ฐ€ ์—†์Šต๋‹ˆ๋‹ค try-with-resources.

ํŒŒ์ผ ๋ณต์‚ฌ์˜ ์˜ˆ

์•”ํ˜ธ ๋ฉ”๋ชจ
String src = "c:\\projects\\log.txt";
String dest = "c:\\projects\\copy.txt";

try(FileInputStream input = new FileInputStream(src);
FileOutputStream output = new FileOutputStream(dest))
{
   byte[] buffer = new byte[65536]; // 64Kb
   while (input.available() > 0)
   {
      int real = input.read(buffer);
      output.write(buffer, 0, real);
   }
}



InputStreamํŒŒ์ผ์—์„œ ์ฝ๊ธฐ
OutputStream์œ„ํ•ด ํŒŒ์ผ์— ์“ฐ๊ธฐ ์œ„ํ•ด

๋ฐ์ดํ„ฐ๋ฅผ ์ฝ์„ ๋ฒ„ํผ
์ŠคํŠธ๋ฆผ์— ๋ฐ์ดํ„ฐ๊ฐ€ ์žˆ๋Š” ํ•œ

๋ฒ„ํผ๋กœ ๋ฐ์ดํ„ฐ
์ฝ๊ธฐ ๋ฒ„ํผ์—์„œ ๋‘ ๋ฒˆ์งธ ์ŠคํŠธ๋ฆผ์œผ๋กœ ๋ฐ์ดํ„ฐ ์“ฐ๊ธฐ

2. Writerํด๋ž˜์Šค

ํด๋ž˜์Šค ๋Š” ํด๋ž˜์Šค Writer์™€ ์ •ํ™•ํžˆ ๋™์ผ OutputStreamํ•˜์ง€๋งŒ ํ•œ ๊ฐ€์ง€ ์ฐจ์ด์ ์ด ์žˆ์Šต๋‹ˆ๋‹ค. char๋ฐ”์ดํŠธ ๋Œ€์‹  ๋ฌธ์ž( )๋กœ ์ž‘๋™ํ•ฉ๋‹ˆ๋‹ค.

์ด๊ฒƒ์€ ์ถ”์ƒ ํด๋ž˜์Šค์ž…๋‹ˆ๋‹ค. Writerํด๋ž˜์Šค์˜ ๊ฐœ์ฒด๋ฅผ ๋งŒ๋“ค ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค. ์ฃผ์š” ๋ชฉํ‘œ๋Š” ์ˆ˜๋ฐฑ ๊ฐœ์˜ ํ•˜์œ„ ํด๋ž˜์Šค์— ๋Œ€ํ•œ ๊ณตํ†ต ์ƒ์œ„ ํด๋ž˜์Šค๊ฐ€ ๋˜๊ณ  ๋ฌธ์ž ์ŠคํŠธ๋ฆผ ์ž‘์—…์„ ์œ„ํ•œ ๊ณตํ†ต ๋ฉ”์„œ๋“œ๋ฅผ ์ œ๊ณตํ•˜๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค.

ํด๋ž˜์Šค ์˜ ๋ฉ”์„œ๋“œ Writer(๋ฐ ๋ชจ๋“  ํ•˜์œ„ ํด๋ž˜์Šค):

ํ–‰๋™ ์–‘์‹ ์„ค๋ช…
void write(int b)
int์ŠคํŠธ๋ฆผ์— ํ•˜๋‚˜์˜ ๋ฌธ์ž( ๊ฐ€ ์•„๋‹˜)๋ฅผ ์”๋‹ˆ๋‹ค .
void write(char[] buffer)
์ŠคํŠธ๋ฆผ์— ๋ฌธ์ž ๋ฐฐ์—ด์„ ์”๋‹ˆ๋‹ค.
void write(char[] buffer, off, len)
๋ฌธ์ž ๋ฐฐ์—ด์˜ ์ผ๋ถ€๋ฅผ ์ŠคํŠธ๋ฆผ์— ์”๋‹ˆ๋‹ค.
void write(String str)
์ŠคํŠธ๋ฆผ์— ๋ฌธ์ž์—ด์„ ์”๋‹ˆ๋‹ค.
void write(String str, off, len)
๋ฌธ์ž์—ด์˜ ์ผ๋ถ€๋ฅผ ์ŠคํŠธ๋ฆผ์— ์”๋‹ˆ๋‹ค.
void flush()
๋ฒ„ํผ์— ์ €์žฅ๋œ ๋ชจ๋“  ๋ฐ์ดํ„ฐ๋ฅผ ์ŠคํŠธ๋ฆผ์— ์”๋‹ˆ๋‹ค.
void close()
์ŠคํŠธ๋ฆผ์„ ๋‹ซ์Šต๋‹ˆ๋‹ค

๋ฉ”์†Œ๋“œ๋Š” ํด๋ž˜์Šค์˜ ๋ฉ”์†Œ๋“œ์™€ ๋งค์šฐ ์œ ์‚ฌ OutputStreamํ•˜์ง€๋งŒ ๋ฐ”์ดํŠธ ๋Œ€์‹  ๋ฌธ์ž๋กœ ์ž‘๋™ํ•ฉ๋‹ˆ๋‹ค.

๋ฐฉ๋ฒ• ์„ค๋ช…:

write(int b)๋ฐฉ๋ฒ•

์ด ๋ฉ”์„œ๋“œ๋Š” ์ถœ๋ ฅ ์ŠคํŠธ๋ฆผ์— ๋‹จ์ผ ๋ฌธ์ž( charโ€” ์•„๋‹˜ )๋ฅผ ์”๋‹ˆ๋‹ค. int์ „๋‹ฌ๋œ ๊ฐ’์€ ๋กœ ์บ์ŠคํŠธ๋˜๊ณ  char์ฒ˜์Œ ๋‘ ๋ฐ”์ดํŠธ๋Š” ๋ฒ„๋ ค์ง‘๋‹ˆ๋‹ค.

write(char[] buffer)๋ฐฉ๋ฒ•

์ง€์ •๋œ ๋ฌธ์ž ๋ฐฐ์—ด์„ ์ถœ๋ ฅ ์ŠคํŠธ๋ฆผ์— ์”๋‹ˆ๋‹ค.

write(char[] buffer, int offset, int length)๋ฐฉ๋ฒ•

์ „๋‹ฌ๋œ ๋ฌธ์ž ๋ฐฐ์—ด์˜ ์ผ๋ถ€๋ฅผ ์ถœ๋ ฅ ์ŠคํŠธ๋ฆผ์— ์”๋‹ˆ๋‹ค. ๋ณ€์ˆ˜ offset๋Š” ๋ฐฐ์—ด์˜ ์ฒซ ๋ฒˆ์งธ ์š”์†Œ์˜ ์ธ๋ฑ์Šค๋ฅผ ๋‚˜ํƒ€๋‚ด๋ฉฐ length๊ธฐ๋กํ•  ํ•˜์œ„ ์ง‘ํ•ฉ์˜ ๊ธธ์ด์ž…๋‹ˆ๋‹ค.

write(String str)๋ฐฉ๋ฒ•

์ฃผ์–ด์ง„ ๋ฌธ์ž์—ด์„ ์ถœ๋ ฅ ์ŠคํŠธ๋ฆผ์— ์”๋‹ˆ๋‹ค.

write(String str, int offset, int length)๋ฐฉ๋ฒ•

์ฃผ์–ด์ง„ ๋ฌธ์ž์—ด์˜ ์ผ๋ถ€๋ฅผ ์ถœ๋ ฅ ์ŠคํŠธ๋ฆผ์— ์”๋‹ˆ๋‹ค. ๋ฌธ์ž์—ด์€ ๋ฌธ์ž ๋ฐฐ์—ด๋กœ ๋ณ€ํ™˜๋ฉ๋‹ˆ๋‹ค. ๋ณ€์ˆ˜ offset๋Š” ๋ฐฐ์—ด์˜ ์ฒซ ๋ฒˆ์งธ ์š”์†Œ์˜ ์ธ๋ฑ์Šค๋ฅผ ๋‚˜ํƒ€๋‚ด๋ฉฐ length๊ธฐ๋กํ•  ํ•˜์œ„ ์ง‘ํ•ฉ์˜ ๊ธธ์ด์ž…๋‹ˆ๋‹ค.

flush()๋ฐฉ๋ฒ•

์ด flush()๋ฉ”์„œ๋“œ๋Š” ํ˜„์žฌ ์ŠคํŠธ๋ฆผ์— ์ž ์žฌ์ ์œผ๋กœ ๋ฒ„ํผ๋ง๋œ ๋ชจ๋“  ๋ฐ์ดํ„ฐ๋ฅผ ๋Œ€์ƒ ์ŠคํŠธ๋ฆผ์— ๊ธฐ๋กํ•˜๋Š” ๋ฐ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค. ์ด๋Š” ๋ฒ„ํผ๋ง ๋ฐ/๋˜๋Š” ์ฒด์ธ์— ๋ฐฐ์—ด๋œ ์—ฌ๋Ÿฌ ์ŠคํŠธ๋ฆผ ๊ฐœ์ฒด๋ฅผ ์‚ฌ์šฉํ•  ๋•Œ ๊ด€๋ จ์ด ์žˆ์Šต๋‹ˆ๋‹ค.

close()๋ฐฉ๋ฒ•

๊ธฐ๋ก๋˜์ง€ ์•Š์€ ๋ชจ๋“  ๋ฐ์ดํ„ฐ๋ฅผ ๋Œ€์ƒ ๊ฐœ์ฒด์— ์”๋‹ˆ๋‹ค. close()๋ธ”๋ก ์„ ์‚ฌ์šฉํ•˜๋Š” ๊ฒฝ์šฐ ๋ฉ”์„œ๋“œ๋ฅผ ํ˜ธ์ถœํ•  ํ•„์š”๊ฐ€ ์—†์Šต๋‹ˆ๋‹ค try-with-resources.

ํ…์ŠคํŠธ ํŒŒ์ผ์„ ๋ณต์‚ฌํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์˜ ์˜ˆ:

์•”ํ˜ธ ๋ฉ”๋ชจ
String src = "c:\\projects\\log.txt";
String dest = "c:\\projects\\copy.txt";

try(FileReader reader = new FileReader(src);
FileWriter writer = new FileWriter(dest))
{
   char[] buffer = new char[65536]; // 128Kb
   while (reader.ready())
   {
      int real = reader.read(buffer);
      writer.write(buffer, 0, real);
   }
}



ReaderํŒŒ์ผ์—์„œ ์ฝ๊ธฐ
Writer์œ„ํ•ด ํŒŒ์ผ์— ์“ฐ๊ธฐ ์œ„ํ•ด

๋ฐ์ดํ„ฐ๋ฅผ ์ฝ์„ ๋ฒ„ํผ
์ŠคํŠธ๋ฆผ์— ๋ฐ์ดํ„ฐ๊ฐ€ ์žˆ๋Š” ํ•œ

๋ฒ„ํผ๋กœ ๋ฐ์ดํ„ฐ
์ฝ๊ธฐ ๋ฒ„ํผ์—์„œ ๋‘ ๋ฒˆ์งธ ์ŠคํŠธ๋ฆผ์œผ๋กœ ๋ฐ์ดํ„ฐ ์“ฐ๊ธฐ

StringWriter์ˆ˜์—…

Writerํด๋ž˜์Šค๋ฅผ ์ƒ์†ํ•˜๋Š” ๋˜ ๋‹ค๋ฅธ ํฅ๋ฏธ๋กœ์šด ํด๋ž˜์Šค๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค StringWriter. ์—ฌ๊ธฐ์—๋Š” ๋ณ€๊ฒฝ ๊ฐ€๋Šฅํ•œ ๋ฌธ์ž์—ด์ธ StringBuffer๊ฐ์ฒด๊ฐ€ ํฌํ•จ๋ฉ๋‹ˆ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ๊ฐœ์ฒด์— ๋ฌด์–ธ๊ฐ€๋ฅผ "์“ธ" ๋•Œ๋งˆ๋‹ค StringWriterํ…์ŠคํŠธ๋Š” ๋‹จ์ˆœํžˆ ๋‚ด๋ถ€ ๋ฒ„ํผ์— ์ถ”๊ฐ€๋ฉ๋‹ˆ๋‹ค.

์˜ˆ:

์•”ํ˜ธ ๋ฉ”๋ชจ
StringWriter writer = new StringWriter();
writer.write("Hello");
writer.write(String.valueOf(123));

String result = writer.toString();
๋Œ€์ƒ ๋ฌธ์ž ์ŠคํŠธ๋ฆผ( StringWriter)์ด ์ƒ์„ฑ๋ฉ๋‹ˆ๋‹ค.
๋ฌธ์ž์—ด์ด ๋‚ด๋ถ€ ๋ฒ„ํผ์— ๊ธฐ๋ก๋ฉ๋‹ˆ๋‹ค. StringWriter
๋ฌธ์ž์—ด์ด ๋‚ด๋ถ€ ๋ฒ„ํผ์— ๊ธฐ๋ก๋ฉ๋‹ˆ๋‹ค. StringWriter

๊ฐ์ฒด์˜ ๋‚ด์šฉ์„ ๋ฌธ์ž์—ด๋กœ ๋ณ€ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

์ด ๊ฒฝ์šฐ StringWriterํด๋ž˜์Šค๋Š” ๊ธฐ๋ณธ์ ์œผ๋กœ ํด๋ž˜์Šค์— ๋Œ€ํ•œ ๋ž˜ํผ StringBuffer์ด์ง€๋งŒ StringWriterํด๋ž˜์Šค๋Š” ์ŠคํŠธ๋ฆผ ํด๋ž˜์Šค์˜ ํ›„์† Writer์ด๋ฉฐ ์ŠคํŠธ๋ฆผ ๊ฐœ์ฒด ์ฒด์ธ์—์„œ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด๊ฒƒ์€ ์‹ค์ œ๋กœ ๋งค์šฐ ์œ ์šฉํ•œ ์†์„ฑ์ž…๋‹ˆ๋‹ค.



3. PrintStreamํด๋ž˜์Šค

์ถœ๋ ฅ ์ŠคํŠธ๋ฆผ ํด๋ž˜์Šค๋Š” ์ „๋‹ฌ๋œ ๋Œ€์ƒ ์ŠคํŠธ๋ฆผ์— ๋ฐ์ดํ„ฐ๋ฅผ ์“ฐ๋Š” ์ค‘๊ฐ„ ์ŠคํŠธ๋ฆผ์ด ์žˆ๋Š” ์ฒด์ธ์— ๋„ฃ์„ ์ˆ˜๋„ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด๋Ÿฌํ•œ ์ŠคํŠธ๋ฆผ์˜ ์ƒํ˜ธ ์ž‘์šฉ์— ๋Œ€ํ•œ ์ผ๋ฐ˜์ ์ธ ๋ณด๊ธฐ๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

PrintStream ํด๋ž˜์Šค

๋ชจ๋“  ์ค‘๊ฐ„ ์ถœ๋ ฅ ์ŠคํŠธ๋ฆผ ์ค‘์—์„œ ๊ฐ€์žฅ ํฅ๋ฏธ๋กญ๊ณ  ๋‹ค์žฌ๋‹ค๋Šฅํ•œ ๊ฒƒ์€ PrintStream. ์ˆ˜์‹ญ ๊ฐœ์˜ ๋ฉ”์†Œ๋“œ์™€ ๋งŽ๊ฒŒ๋Š” 12๊ฐœ์˜ ์ƒ์„ฑ์ž๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค.

ํด๋ž˜์Šค ๋Š” ํด๋ž˜์Šค๋ฅผ PrintStream์ƒ์†ํ•˜๊ณ  FilterOutputStreamํด๋ž˜์Šค๋Š” OutputStream. ์ฆ‰, ํด๋ž˜์Šค๋Š” ์ž์ฒด ๋ฉ”์„œ๋“œ ์™ธ์—๋„ ๋ถ€๋ชจ ํด๋ž˜์Šค์˜ ๋ชจ๋“  ๋ฉ”์„œ๋“œ๋ฅผPrintStream ๊ฐ€์ง‘๋‹ˆ๋‹ค . ๋‹ค์Œ์€ ๊ฐ€์žฅ ํฅ๋ฏธ๋กœ์šด ๊ฒƒ์ž…๋‹ˆ๋‹ค.

ํ–‰๋™ ์–‘์‹ ์„ค๋ช…
void print(obj)
์ „๋‹ฌ๋œ ๊ฐœ์ฒด๋ฅผ ๋ฌธ์ž์—ด๋กœ ๋ณ€ํ™˜ํ•˜๊ณ  ๋Œ€์ƒ ์ŠคํŠธ๋ฆผ์— ์ถœ๋ ฅํ•ฉ๋‹ˆ๋‹ค.
void println(obj)
์ „๋‹ฌ๋œ ๊ฐœ์ฒด๋ฅผ ๋ฌธ์ž์—ด๋กœ ๋ณ€ํ™˜ํ•˜๊ณ  ๋Œ€์ƒ ์ŠคํŠธ๋ฆผ์— ์ถœ๋ ฅํ•ฉ๋‹ˆ๋‹ค. ๋์— ์ค„ ๋ฐ”๊ฟˆ์„ ์ถ”๊ฐ€ํ•ฉ๋‹ˆ๋‹ค.
void println()
๋Œ€์ƒ ์ŠคํŠธ๋ฆผ์— ์ค„ ๋ฐ”๊ฟˆ ๋ฌธ์ž๋ฅผ ์ถœ๋ ฅํ•ฉ๋‹ˆ๋‹ค.
PrintStream format(String format, args...)
ํ˜•์‹ ๋ฌธ์ž์—ด๊ณผ ์ „๋‹ฌ๋œ ์ธ์ˆ˜๋ฅผ ๊ธฐ๋ฐ˜์œผ๋กœ ๋ฌธ์ž์—ด์„ ๊ตฌ์„ฑํ•˜๊ณ  ์ถœ๋ ฅํ•ฉ๋‹ˆ๋‹ค. String.format()๋ฐฉ๋ฒ• ๊ณผ ์œ ์‚ฌ

๊ทธ๋ฆฌ๊ณ ์ด ์ˆ˜์‹ญ ๊ฐ€์ง€ ๋ฐฉ๋ฒ•์€ ์–ด๋””์— ์žˆ์Šต๋‹ˆ๊นŒ?

์Œ, ๋งค๊ฐœ ๋ณ€์ˆ˜๊ฐ€ ๋‹ค๋ฅธ ๋‹ค์–‘ํ•œ ๋ณ€ํ˜• print()๋ฐ ๋ฉ”์„œ๋“œ ๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค . println()์ด ํ‘œ์— ์š”์•ฝํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์ด๋Ÿฌํ•œ ๋ฐฉ๋ฒ•์€ ์ด๋ฏธ ์ž˜ ์•Œ๊ณ  ์žˆ๊ธฐ ๋•Œ๋ฌธ์— ์—ฌ๊ธฐ์„œ๋Š” ๋‹ค๋ฃจ์ง€ ์•Š๊ฒ ์Šต๋‹ˆ๋‹ค. ๋‚ด๊ฐ€ ๋ฌด์—‡์„ ์–ป๊ณ  ์žˆ๋Š”์ง€ ์ง์ž‘ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๊นŒ?

๊ธฐ์–ต๋‚˜ System.out.println()? ๊ทธ๋Ÿฌ๋‚˜ ๋‘ ์ค„๋กœ ์ž‘์„ฑํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์•”ํ˜ธ ์ฝ˜์†” ์ถœ๋ ฅ
PrintStream stream = System.out;
stream.println("Hello!");
Hello!

์šฐ๋ฆฌ๊ฐ€ ๊ฐ€์žฅ ์ข‹์•„ํ•˜๋Š” ๋ช…๋ น์€ ํด๋ž˜์Šค ์˜ ์ •์  ๋ณ€์ˆ˜์— ๋Œ€ํ•œ ๋ฉ”์„œ๋“œ ํ˜ธ์ถœ์ž…๋‹ˆ๋‹ค . ๊ทธ๋ฆฌ๊ณ  ์ด ๋ณ€์ˆ˜์˜ ํƒ€์ž…์€ .System.out.println()println()outSystemPrintStream

๋งŽ์€ CodeGym ๋ ˆ๋ฒจ๊ณผ ๊ฑฐ์˜ ๋ชจ๋“  ์ž‘์—…์—์„œ PrintStream์•Œ์ง€๋„ ๋ชปํ•˜๋Š” ์‚ฌ์ด์— ํด๋ž˜์Šค์˜ ๋ฉ”์„œ๋“œ๋ฅผ ํ˜ธ์ถœํ•ด ์™”์Šต๋‹ˆ๋‹ค!

์‹ค์šฉ

Java์—๋Š” ์ด๋ผ๋Š” ํฅ๋ฏธ๋กœ์šด ํด๋ž˜์Šค๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค ByteArrayOutputStream. ์ด ํด๋ž˜์Šค๋Š” ๋ฅผ ์ƒ์†ํ•˜๋Š” ๋™์ ์œผ๋กœ ์ฆ๊ฐ€ํ•˜๋Š” ๋ฐ”์ดํŠธ ๋ฐฐ์—ด์ž…๋‹ˆ๋‹ค OutputStream.

๊ฐ์ฒด ByteArrayOutputStream์™€ PrintStream๊ฐ์ฒด๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์ด ์—ฐ๊ฒฐํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์•”ํ˜ธ ์„ค๋ช…
ByteArrayOutputStream baos = new ByteArrayOutputStream();

try(PrintStream stream = new PrintStream(baos))
{
   stream.println("Hello");
   stream.println(123);
}

String result = baos.toString();

System.out.println(result);
๋ฉ”๋ชจ๋ฆฌ์— ์“ฐ๊ธฐ ๋ฒ„ํผ ์ƒ์„ฑ ๊ฐœ์ฒด

์— ๋ฒ„ํผ๋ฅผ ๋ž˜ํ•‘ ์ฝ˜์†”์— ๋ฐ์ดํ„ฐ ์“ฐ๊ธฐ ๋ฐฐ์—ด์„ ๋ฌธ์ž์—ด๋กœ ๋ณ€ํ™˜! ์ฝ˜์†” ์ถœ๋ ฅ:PrintStream








Hello!
123