1. ๋ฐ์ดํ„ฐ ์ŠคํŠธ๋ฆผ

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

ํ”„๋กœ๊ทธ๋žจ๊ณผ ์™ธ๋ถ€ ์„ธ๊ณ„ ๊ฐ„์˜ ๋ฐ์ดํ„ฐ ๊ตํ™˜ ์ด๋ผ๋Š” ํ•œ ๋‹จ์–ด๋กœ ์ด๋Ÿฌํ•œ ๋ชจ๋“  ๋™์ž‘์„ ์–ธ๊ธ‰ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค . ์ž ๊น, ํ•œ ๋‹จ์–ด๊ฐ€ ์•„๋‹™๋‹ˆ๋‹ค.

๋ฌผ๋ก  ๋ฐ์ดํ„ฐ ๊ตํ™˜ ์ž์ฒด๋Š” ๋ฐ์ดํ„ฐ ์ˆ˜์‹ ๊ณผ ๋ฐ์ดํ„ฐ ์ „์†ก์˜ ๋‘ ๋ถ€๋ถ„์œผ๋กœ ๋‚˜๋ˆŒ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด, ๊ฐœ์ฒด๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ํ‚ค๋ณด๋“œ์—์„œ ๋ฐ์ดํ„ฐ๋ฅผ ์ฝ์Šต๋‹ˆ๋‹ค Scanner. ์ด๊ฒƒ์€ ๋ฐ์ดํ„ฐ๋ฅผ ๋ฐ›๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. ๊ทธ๋ฆฌ๊ณ  ๋ช…๋ น์„ ์‚ฌ์šฉํ•˜์—ฌ ํ™”๋ฉด์— ๋ฐ์ดํ„ฐ๋ฅผ ํ‘œ์‹œํ•ฉ๋‹ˆ๋‹ค System.out.println(). ์ด๊ฒƒ์ด ๋ฐ์ดํ„ฐ ์ „์†ก์ž…๋‹ˆ๋‹ค.

ํ”„๋กœ๊ทธ๋ž˜๋ฐ์—์„œ "์ŠคํŠธ๋ฆผ"์ด๋ผ๋Š” ์šฉ์–ด๋Š” ๋ฐ์ดํ„ฐ ๊ตํ™˜์„ ์„ค๋ช…ํ•˜๋Š” ๋ฐ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค. ๊ทธ ์šฉ์–ด๋Š” ์–ด๋””์—์„œ ์™”์Šต๋‹ˆ๊นŒ?

์‹ค์ƒํ™œ์—์„œ๋Š” ๋ฌผ์˜ ํ๋ฆ„์ด๋‚˜ ์˜์‹์˜ ํ๋ฆ„์„ ๊ฐ€์งˆ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ํ”„๋กœ๊ทธ๋ž˜๋ฐ์—๋Š” ๋ฐ์ดํ„ฐ ์ŠคํŠธ๋ฆผ์ด ์žˆ์Šต๋‹ˆ๋‹ค .

์ŠคํŠธ๋ฆผ์€ ๋‹ค๋ชฉ์  ๋„๊ตฌ์ž…๋‹ˆ๋‹ค. ์ด๋ฅผ ํ†ตํ•ด ํ”„๋กœ๊ทธ๋žจ์€ ์–ด๋””์—์„œ๋‚˜ ๋ฐ์ดํ„ฐ๋ฅผ ์ˆ˜์‹ ํ•˜๊ณ (์ž…๋ ฅ ์ŠคํŠธ๋ฆผ) ์–ด๋””์—์„œ๋‚˜ ๋ฐ์ดํ„ฐ๋ฅผ ๋ณด๋‚ผ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค(์ถœ๋ ฅ ์ŠคํŠธ๋ฆผ). ๋”ฐ๋ผ์„œ ๋‘ ๊ฐ€์ง€ ์œ ํ˜•์ด ์žˆ์Šต๋‹ˆ๋‹ค.

  • ์ž…๋ ฅ ์ŠคํŠธ๋ฆผ์€ ๋ฐ์ดํ„ฐ๋ฅผ ์ˆ˜์‹ ํ•˜๊ธฐ ์œ„ํ•œ ๊ฒƒ์ž…๋‹ˆ๋‹ค.
  • ์ถœ๋ ฅ ์ŠคํŠธ๋ฆผ์€ ๋ฐ์ดํ„ฐ๋ฅผ ์ „์†กํ•˜๊ธฐ ์œ„ํ•œ ๊ฒƒ์ž…๋‹ˆ๋‹ค.

์ŠคํŠธ๋ฆผ์„ '์œ ํ˜•'์œผ๋กœ ๋งŒ๋“ค๊ธฐ ์œ„ํ•ด Java ์ž‘์„ฑ์ž๋Š” InputStream๋ฐ ์ด๋ผ๋Š” ๋‘ ๊ฐ€์ง€ ํด๋ž˜์Šค๋ฅผ ์ž‘์„ฑํ–ˆ์Šต๋‹ˆ๋‹ค OutputStream.

ํด๋ž˜์Šค ์—๋Š” ๋ฐ์ดํ„ฐ๋ฅผ ์ฝ์„ ์ˆ˜ ์žˆ๋Š” ๋ฉ”์„œ๋“œ๊ฐ€ InputStream์žˆ์Šต๋‹ˆ๋‹ค . read()๊ทธ๋ฆฌ๊ณ  ํด๋ž˜์Šค ์—๋Š” ๋ฐ์ดํ„ฐ๋ฅผ ์“ธ ์ˆ˜ ์žˆ๋Š” ๋ฉ”์„œ๋“œ๊ฐ€ OutputStream์žˆ์Šต๋‹ˆ๋‹ค . write()๋‹ค๋ฅธ ๋ฐฉ๋ฒ•๋„ ์žˆ์ง€๋งŒ ๋‚˜์ค‘์— ์ž์„ธํžˆ ์„ค๋ช…ํ•ฉ๋‹ˆ๋‹ค.

๋ฐ”์ดํŠธ ์ŠคํŠธ๋ฆผ

์šฐ๋ฆฌ๋Š” ์–ด๋–ค ์ข…๋ฅ˜์˜ ๋ฐ์ดํ„ฐ์— ๋Œ€ํ•ด ์ด์•ผ๊ธฐํ•˜๊ณ  ์žˆ์Šต๋‹ˆ๊นŒ? ์–ด๋–ค ํ˜•์‹์„ ์ทจํ•ฉ๋‹ˆ๊นŒ? ์ฆ‰, ์ด๋Ÿฌํ•œ ํด๋ž˜์Šค๋Š” ์–ด๋–ค ๋ฐ์ดํ„ฐ ์œ ํ˜•์„ ์ง€์›ํ•ฉ๋‹ˆ๊นŒ?

์ด๋“ค์€ ์ผ๋ฐ˜ ํด๋ž˜์Šค์ด๋ฏ€๋กœ ๊ฐ€์žฅ ์ผ๋ฐ˜์ ์ธ ๋ฐ์ดํ„ฐ ์œ ํ˜•์ธ byte. An์€ OutputStream๋ฐ”์ดํŠธ(๋ฐ ๋ฐ”์ดํŠธ ๋ฐฐ์—ด)๋ฅผ ์“ธ ์ˆ˜ ์žˆ๊ณ  InputStream๊ฐ์ฒด๋Š” ๋ฐ”์ดํŠธ(๋˜๋Š” ๋ฐ”์ดํŠธ ๋ฐฐ์—ด)๋ฅผ ์ฝ์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๊ทธ๊ฒŒ ์ „๋ถ€์ž…๋‹ˆ๋‹ค. ๋‹ค๋ฅธ ๋ฐ์ดํ„ฐ ์œ ํ˜•์€ ์ง€์›ํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

๋”ฐ๋ผ์„œ ์ด๋Ÿฌํ•œ ์ŠคํŠธ๋ฆผ์„ ๋ฐ”์ดํŠธ ์ŠคํŠธ๋ฆผ ์ด๋ผ๊ณ ๋„ ํ•ฉ๋‹ˆ๋‹ค .

์ŠคํŠธ๋ฆผ์˜ ํ•œ ๊ฐ€์ง€ ๊ธฐ๋Šฅ์€ ํ•ด๋‹น ๋ฐ์ดํ„ฐ๋ฅผ ์ˆœ์ฐจ์ ์œผ๋กœ๋งŒ ์ฝ์„(๋˜๋Š” ์“ธ ์ˆ˜) ์ˆ˜ ์žˆ๋‹ค๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. ์•ž์— ์˜ค๋Š” ๋ชจ๋“  ๋ฐ์ดํ„ฐ๋ฅผ ์ฝ์ง€ ์•Š๊ณ ๋Š” ์ŠคํŠธ๋ฆผ ์ค‘๊ฐ„์—์„œ ๋ฐ์ดํ„ฐ๋ฅผ ์ฝ์„ ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค.

์ด๊ฒƒ์ด ํด๋ž˜์Šค ์ „์ฒด์—์„œ ํ‚ค๋ณด๋“œ์—์„œ ๋ฐ์ดํ„ฐ๋ฅผ ์ฝ๋Š” ๋ฐฉ์‹์ž…๋‹ˆ๋‹ค Scanner. ํ‚ค๋ณด๋“œ์—์„œ ํ•œ ์ค„์”ฉ ์ˆœ์ฐจ์ ์œผ๋กœ ๋ฐ์ดํ„ฐ๋ฅผ ์ฝ์Šต๋‹ˆ๋‹ค. ํ•œ ์ค„, ๋‹ค์Œ ์ค„, ๋‹ค์Œ ์ค„ ๋“ฑ์„ ์ฝ์Šต๋‹ˆ๋‹ค. ์ ์ ˆํ•˜๊ฒŒ๋„ ํ–‰์„ ์ฝ๋Š” ๋ฐฉ๋ฒ•์„ ์ด๋ผ๊ณ  ํ•ฉ๋‹ˆ๋‹ค nextLine().

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

๋ฌธ์ž ์ŠคํŠธ๋ฆผ

์ตœ๊ทผ์— ๋ฌธ์ž์—ด์ด ๋‘ ๋ฒˆ์งธ๋กœ ๋งŽ์ด ์‚ฌ์šฉ๋˜๋Š” ๋ฐ์ดํ„ฐ ์œ ํ˜•์ด๋ผ๋Š” ์‚ฌ์‹ค์„ ์•Œ๊ฒŒ ๋˜์—ˆ์œผ๋ฉฐ ์‹ค์ œ๋กœ ๊ทธ๋ ‡์Šต๋‹ˆ๋‹ค. ๋งŽ์€ ์ •๋ณด๊ฐ€ ๋ฌธ์ž์™€ ์ „์ฒด ๋ฌธ์ž์—ด์˜ ํ˜•ํƒœ๋กœ ์ „๋‹ฌ๋ฉ๋‹ˆ๋‹ค. ์ปดํ“จํ„ฐ๋Š” ๋ชจ๋“  ๊ฒƒ์„ ๋ฐ”์ดํŠธ๋กœ ๋ณด๋‚ด๊ณ  ๋ฐ›๋Š” ๋ฐ ํƒ์›”ํ•˜์ง€๋งŒ ์ธ๊ฐ„์€ ์™„๋ฒฝํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

์ด ์‚ฌ์‹ค์„ ๊ณ ๋ คํ•˜์—ฌ Java ํ”„๋กœ๊ทธ๋ž˜๋จธ๋Š” ๋‘ ๊ฐœ์˜ ํด๋ž˜์Šค๋ฅผ ๋” ์ž‘์„ฑ Readerํ–ˆ์Šต๋‹ˆ๋‹ค Writer. ํด๋ž˜์Šค Reader๋Š” ํด๋ž˜์Šค์™€ ์œ ์‚ฌ InputStreamํ•˜์ง€๋งŒ read()๋ฉ”์†Œ๋“œ๋Š” ๋ฐ”์ดํŠธ๊ฐ€ ์•„๋‹ˆ๋ผ ๋ฌธ์ž( char)๋ฅผ ์ฝ์Šต๋‹ˆ๋‹ค. ํด๋ž˜์Šค ๋Š” ํด๋ž˜์Šค Writer์— ํ•ด๋‹นํ•ฉ๋‹ˆ๋‹ค OutputStream. ๊ทธ๋ฆฌ๊ณ  ํด๋ž˜์Šค์™€ ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ ๋ฐ”์ดํŠธ๊ฐ€ ์•„๋‹Œ Reader๋ฌธ์ž( )๋กœ ์ž‘๋™ํ•ฉ๋‹ˆ๋‹ค .char

์ด ๋„ค ๊ฐ€์ง€ ํด๋ž˜์Šค๋ฅผ ๋น„๊ตํ•˜๋ฉด ๋‹ค์Œ ๊ทธ๋ฆผ์„ ์–ป์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๋ฐ”์ดํŠธ(๋ฐ”์ดํŠธ) ๋ฌธ์ž(char)
๋ฐ์ดํ„ฐ ์ฝ๊ธฐ
InputStream
Reader
๋ฐ์ดํ„ฐ ์“ฐ๊ธฐ
OutputStream
Writer

์‹ค์šฉ์ ์ธ ์‘์šฉ ํ”„๋กœ๊ทธ๋žจ

, ๋ฐ ํด๋ž˜์Šค ์ž์ฒด๋Š” ๋ฐ์ดํ„ฐ InputStream๋ฅผ ์ฝ์„ ์ˆ˜ ์žˆ๋Š”(๋˜๋Š” ๋ฐ์ดํ„ฐ ๋ฅผ ์“ธ ์ˆ˜ ์žˆ๋Š”) ๊ตฌ์ฒด์ ์ธ ๊ฐœ์ฒด์™€ ์—ฐ๊ฒฐ๋˜์–ด ์žˆ์ง€ ์•Š๊ธฐ ๋•Œ๋ฌธ์— ๋ˆ„๊ตฌ๋„ ์ง์ ‘ ์‚ฌ์šฉํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ํ•˜์ง€๋งŒ ์ด ๋„ค ๊ฐ€์ง€ ํด๋ž˜์Šค์—๋Š” ๋งŽ์€ ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•  ์ˆ˜ ์žˆ๋Š” ๋งŽ์€ ์ž์† ํด๋ž˜์Šค๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค.OutputStreamReaderWriter


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

์ด InputStreamํด๋ž˜์Šค๋Š” ์ˆ˜๋ฐฑ ๊ฐœ์˜ ํ•˜์œ„ ํด๋ž˜์Šค์— ๋Œ€ํ•œ ์ƒ์œ„ ํด๋ž˜์Šค์ด๊ธฐ ๋•Œ๋ฌธ์— ํฅ๋ฏธ๋กญ์Šต๋‹ˆ๋‹ค. ์ž์ฒด ๋ฐ์ดํ„ฐ๋Š” ์—†์ง€๋งŒ ๋ชจ๋“  ํŒŒ์ƒ ํด๋ž˜์Šค๊ฐ€ ์ƒ์†ํ•˜๋Š” ๋ฉ”์„œ๋“œ๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค.

์ผ๋ฐ˜์ ์œผ๋กœ ์ŠคํŠธ๋ฆผ ๊ฐœ์ฒด๊ฐ€ ๋‚ด๋ถ€์ ์œผ๋กœ ๋ฐ์ดํ„ฐ๋ฅผ ์ €์žฅํ•˜๋Š” ๊ฒฝ์šฐ๋Š” ๋“œ๋ญ…๋‹ˆ๋‹ค. ์ŠคํŠธ๋ฆผ์€ ๋ฐ์ดํ„ฐ๋ฅผ ์ฝ๊ณ  ์“ฐ๊ธฐ ์œ„ํ•œ ๋„๊ตฌ์ด์ง€๋งŒ ์Šคํ† ๋ฆฌ์ง€๋Š” ์•„๋‹™๋‹ˆ๋‹ค. ์ฆ‰, ์˜ˆ์™ธ๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค.

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

ํ–‰๋™ ์–‘์‹ ์„ค๋ช…
int read()
์ŠคํŠธ๋ฆผ์—์„œ 1๋ฐ”์ดํŠธ๋ฅผ ์ฝ์Šต๋‹ˆ๋‹ค.
int read(byte[] buffer)
์ŠคํŠธ๋ฆผ์—์„œ ๋ฐ”์ดํŠธ ๋ฐฐ์—ด์„ ์ฝ์Šต๋‹ˆ๋‹ค.
byte[] readAllBytes()
์ŠคํŠธ๋ฆผ์—์„œ ๋ชจ๋“  ๋ฐ”์ดํŠธ๋ฅผ ์ฝ์Šต๋‹ˆ๋‹ค.
long skip(long n)
์ŠคํŠธ๋ฆผ์—์„œ ๋ฐ”์ดํŠธ๋ฅผ ๊ฑด๋„ˆ๋œ๋‹ˆ๋‹ค n(์ฝ๊ณ  ๋ฒ„๋ฆฝ๋‹ˆ๋‹ค).
int available()
์ŠคํŠธ๋ฆผ์— ๋‚จ์•„ ์žˆ๋Š” ๋ฐ”์ดํŠธ ์ˆ˜๋ฅผ ํ™•์ธํ•ฉ๋‹ˆ๋‹ค.
void close()
์ŠคํŠธ๋ฆผ์„ ๋‹ซ์Šต๋‹ˆ๋‹ค

๋‹ค์Œ ๋ฐฉ๋ฒ•์„ ๊ฐ„๋‹จํžˆ ์‚ดํŽด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

read()๋ฐฉ๋ฒ•

์ด ๋ฉ”์„œ๋“œ๋Š” ์ŠคํŠธ๋ฆผ์—์„œ 1๋ฐ”์ดํŠธ๋ฅผread() ์ฝ๊ณ  ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. ๋ฐ˜ํ™˜ ์œ ํ˜•์ด ํ˜ผ๋™๋  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค . ์ด ์œ ํ˜•์€ ํ‘œ์ค€ ์ •์ˆ˜ ์œ ํ˜•์ด๊ธฐ ๋•Œ๋ฌธ์— ์„ ํƒ๋˜์—ˆ์Šต๋‹ˆ๋‹ค . ์˜ ์ฒ˜์Œ 3๋ฐ”์ดํŠธ๋Š” 0์ž…๋‹ˆ๋‹ค.intintint

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

์ด๊ฒƒ์€ ๋ฐฉ๋ฒ•์˜ ๋‘ ๋ฒˆ์งธ ๋ณ€ํ˜•์ž…๋‹ˆ๋‹ค read(). InputStreamํ•œ ๋ฒˆ์— ๋ชจ๋‘ ์—์„œ ๋ฐ”์ดํŠธ ๋ฐฐ์—ด์„ ์ฝ์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค . ๋ฐ”์ดํŠธ๋ฅผ ์ €์žฅํ•  ๋ฐฐ์—ด์„ ์ธ์ˆ˜๋กœ ์ „๋‹ฌํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ์ด ๋ฉ”์„œ๋“œ๋Š” ์‹ค์ œ๋กœ ์ฝ์€ ๋ฐ”์ดํŠธ ์ˆ˜์ธ ์ˆซ์ž๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

10ํ‚ฌ๋กœ๋ฐ”์ดํŠธ ๋ฒ„ํผ๊ฐ€ ์žˆ๊ณ  ํด๋ž˜์Šค๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ํŒŒ์ผ์—์„œ ๋ฐ์ดํ„ฐ๋ฅผ ์ฝ๋Š”๋‹ค๊ณ  ๊ฐ€์ •ํ•ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค FileInputStream. ํŒŒ์ผ์— 2ํ‚ฌ๋กœ๋ฐ”์ดํŠธ๋งŒ ํฌํ•จ๋œ ๊ฒฝ์šฐ ๋ชจ๋“  ๋ฐ์ดํ„ฐ๊ฐ€ ๋ฒ„ํผ ๋ฐฐ์—ด๋กœ ๋กœ๋“œ๋˜๊ณ  ๋ฉ”์„œ๋“œ๋Š” ์ˆซ์ž 2048(2ํ‚ฌ๋กœ๋ฐ”์ดํŠธ)์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

readAllBytes()๋ฐฉ๋ฒ•

์•„์ฃผ ์ข‹์€ ๋ฐฉ๋ฒ•์ž…๋‹ˆ๋‹ค. ๊ทธ๊ฒƒ์€ ๋‹ค ๋–จ์–ด์งˆ ๋•Œ๊นŒ์ง€ ๋ชจ๋“  ๋ฐ์ดํ„ฐ๋ฅผ ์ฝ๊ณ  InputStream๋‹จ์ผ ๋ฐ”์ดํŠธ ๋ฐฐ์—ด๋กœ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. ์ด๊ฒƒ์€ ์ž‘์€ ํŒŒ์ผ์„ ์ฝ์„ ๋•Œ ๋งค์šฐ ํŽธ๋ฆฌํ•ฉ๋‹ˆ๋‹ค. ํฐ ํŒŒ์ผ์€ ๋ฌผ๋ฆฌ์ ์œผ๋กœ ๋ฉ”๋ชจ๋ฆฌ์— ๋งž์ง€ ์•Š์„ ์ˆ˜ ์žˆ์œผ๋ฉฐ ๋ฉ”์„œ๋“œ๋Š” ์˜ˆ์™ธ๋ฅผ throwํ•ฉ๋‹ˆ๋‹ค.

skip(long n)๋ฐฉ๋ฒ•

์ด ๋ฐฉ๋ฒ•์„ ์‚ฌ์šฉํ•˜๋ฉด ๊ฐœ์ฒด์—์„œ ์ฒ˜์Œ n๋ฐ”์ดํŠธ๋ฅผ ๊ฑด๋„ˆ๋›ธ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค InputStream. ๋ฐ์ดํ„ฐ๋ฅผ ์—„๊ฒฉํ•˜๊ฒŒ ์ˆœ์ฐจ์ ์œผ๋กœ ์ฝ๊ธฐ ๋•Œ๋ฌธ์— ์ด ๋ฉ”์„œ๋“œ๋Š” ์ŠคํŠธ๋ฆผ์—์„œ ์ฒ˜์Œ n๋ฐ”์ดํŠธ๋ฅผ ์ฝ๊ณ  ๋ฒ„๋ฆฝ๋‹ˆ๋‹ค.

์‹ค์ œ๋กœ ๊ฑด๋„ˆ๋›ด ๋ฐ”์ดํŠธ ์ˆ˜๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค(๋ฐ”์ดํŠธ๋ฅผ ๊ฑด๋„ˆ๋›ฐ๊ธฐ ์ „์— ์ŠคํŠธ๋ฆผ์ด ์ข…๋ฃŒ๋œ ๊ฒฝ์šฐ n).

int available()๋ฐฉ๋ฒ•

์ด ๋ฉ”์„œ๋“œ๋Š” ์ŠคํŠธ๋ฆผ์— ์•„์ง ๋‚จ์•„ ์žˆ๋Š” ๋ฐ”์ดํŠธ ์ˆ˜๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

void close()๋ฐฉ๋ฒ•

๋ฉ”์„œ๋“œ close()๋Š” ๋ฐ์ดํ„ฐ ์ŠคํŠธ๋ฆผ์„ ๋‹ซ๊ณ  ์—ฐ๊ฒฐ๋œ ์™ธ๋ถ€ ๋ฆฌ์†Œ์Šค๋ฅผ ํ•ด์ œํ•ฉ๋‹ˆ๋‹ค. ์ŠคํŠธ๋ฆผ์ด ๋‹ซํžˆ๋ฉด ๋” ์ด์ƒ ๋ฐ์ดํ„ฐ๋ฅผ ์ฝ์„ ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค.

๋งค์šฐ ํฐ ํŒŒ์ผ์„ ๋ณต์‚ฌํ•˜๋Š” ์˜ˆ์ œ ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•ด ๋ด…์‹œ๋‹ค. readAllBytes()์ „์ฒด ํŒŒ์ผ์„ ๋ฉ”๋ชจ๋ฆฌ๋กœ ์ฝ๋Š” ๋ฐฉ๋ฒ•์„ ์‚ฌ์šฉํ•  ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค . ์˜ˆ:

์•”ํ˜ธ ๋ฉ”๋ชจ
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์œ„ํ•ด ํŒŒ์ผ์— ์“ฐ๊ธฐ ์œ„ํ•ด

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

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

์ด ์˜ˆ์ œ์—์„œ๋Š” ๋‘ ๊ฐœ์˜ ํด๋ž˜์Šค๋ฅผ ์‚ฌ์šฉํ–ˆ์Šต๋‹ˆ๋‹ค. ๋Š” ํŒŒ์ผ์—์„œ ๋ฐ์ดํ„ฐ๋ฅผ ์ฝ๋Š” ๋ฐ ์‚ฌ์šฉ FileInputStream๋˜๋Š” ์ž์† ์ด๊ณ , ๋Š” ํŒŒ์ผ์— ๋ฐ์ดํ„ฐ๋ฅผ ์“ฐ๋Š” ๋ฐ ์‚ฌ์šฉ๋˜๋Š” ์ž์†์ž…๋‹ˆ๋‹ค . ์กฐ๊ธˆ ํ›„์— ๋‘ ๋ฒˆ์งธ ์ˆ˜์—…์— ๋Œ€ํ•ด ์ด์•ผ๊ธฐํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค.InputStreamFileOutputStreamOutputStream

์—ฌ๊ธฐ์„œ ๋˜ ๋‹ค๋ฅธ ํฅ๋ฏธ๋กœ์šด ์ ์€ real๋ณ€์ˆ˜์ž…๋‹ˆ๋‹ค. ํŒŒ์ผ์—์„œ ๋งˆ์ง€๋ง‰ ๋ฐ์ดํ„ฐ ๋ธ”๋ก์„ ์ฝ์„ ๋•Œ ๋ฐ์ดํ„ฐ๊ฐ€ 64KB ๋ฏธ๋งŒ์ผ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ ์ „์ฒด ๋ฒ„ํผ๊ฐ€ ์•„๋‹ˆ๋ผ ๊ทธ ์ผ๋ถ€์ธ ์ฒซ ๋ฒˆ์งธ real๋ฐ”์ดํŠธ๋งŒ ์ถœ๋ ฅํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ์ด๊ฒƒ์ด ๋ฐ”๋กœ write()๋ฐฉ๋ฒ•์—์„œ ์ผ์–ด๋‚˜๋Š” ์ผ์ž…๋‹ˆ๋‹ค.



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

ํด๋ž˜์Šค ๋Š” ํด๋ž˜์Šค Reader์˜ ์™„์ „ํ•œ ์•„๋‚ ๋กœ๊ทธ์ž…๋‹ˆ๋‹ค InputStream. ์œ ์ผํ•œ ์ฐจ์ด์ ์€ char๋ฐ”์ดํŠธ๊ฐ€ ์•„๋‹Œ ๋ฌธ์ž( )๋กœ ์ž‘๋™ํ•œ๋‹ค๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. InputStreamํด๋ž˜์Šค ์™€ ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ Readerํด๋ž˜์Šค๋Š” ๊ทธ ์ž์ฒด๋กœ ์–ด๋””์—๋„ ์‚ฌ์šฉ๋˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ์ˆ˜๋ฐฑ ๊ฐœ์˜ ํ•˜์œ„ ํด๋ž˜์Šค์— ๋Œ€ํ•œ ์ƒ์œ„ ํด๋ž˜์Šค์ด๋ฉฐ ์ด๋“ค ๋ชจ๋‘์— ๋Œ€ํ•œ ๊ณตํ†ต ๋ฉ”์„œ๋“œ๋ฅผ ์ •์˜ํ•ฉ๋‹ˆ๋‹ค.

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

ํ–‰๋™ ์–‘์‹ ์„ค๋ช…
int read()
char์ŠคํŠธ๋ฆผ์—์„œ ํ•˜๋‚˜๋ฅผ ์ฝ์Šต๋‹ˆ๋‹ค.
int read(char[] buffer)
char์ŠคํŠธ๋ฆผ์—์„œ ๋ฐฐ์—ด์„ ์ฝ์Šต๋‹ˆ๋‹ค.
long skip(long n)
์ŠคํŠธ๋ฆผ์„ ๊ฑด๋„ˆ๋œ๋‹ˆ๋‹ค n chars(์ฝ๊ณ  ๋ฒ„๋ฆฝ๋‹ˆ๋‹ค).
boolean ready()
์ŠคํŠธ๋ฆผ์— ์•„์ง ๋‚จ์•„์žˆ๋Š” ๊ฒƒ์ด ์žˆ๋Š”์ง€ ํ™•์ธํ•ฉ๋‹ˆ๋‹ค.
void close()
์ŠคํŠธ๋ฆผ์„ ๋‹ซ์Šต๋‹ˆ๋‹ค

๋ฐฉ๋ฒ•์€ InputStream์•ฝ๊ฐ„์˜ ์ฐจ์ด๊ฐ€ ์žˆ์ง€๋งŒ ํด๋ž˜์Šค์˜ ๋ฐฉ๋ฒ•๊ณผ ๋งค์šฐ ์œ ์‚ฌํ•ฉ๋‹ˆ๋‹ค.

int read()๋ฐฉ๋ฒ•

์ด ๋ฉ”์„œ๋“œ๋Š” char์ŠคํŠธ๋ฆผ์—์„œ ํ•˜๋‚˜๋ฅผ ์ฝ๊ณ  ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. ์œ ํ˜• char์€ ๋กœ ํ™•์žฅ๋˜์ง€๋งŒ int๊ฒฐ๊ณผ์˜ ์ฒ˜์Œ ๋‘ ๋ฐ”์ดํŠธ๋Š” ํ•ญ์ƒ 0์ž…๋‹ˆ๋‹ค.

int read(char[] buffer)๋ฐฉ๋ฒ•

์ด๊ฒƒ์€ ๋ฐฉ๋ฒ•์˜ ๋‘ ๋ฒˆ์งธ ๋ณ€ํ˜•์ž…๋‹ˆ๋‹ค read(). Readerํ•œ ๋ฒˆ์— ๋ชจ๋‘ ์—์„œ char ๋ฐฐ์—ด์„ ์ฝ์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค . ๋ฌธ์ž๋ฅผ ์ €์žฅํ•  ๋ฐฐ์—ด์„ ์ธ์ˆ˜๋กœ ์ „๋‹ฌํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค. ์ด ๋ฉ”์„œ๋“œ๋Š” ์‹ค์ œ๋กœ ์ฝ์€ ๋ฌธ์ž ์ˆ˜์ธ ์ˆซ์ž๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

skip(long n)๋ฐฉ๋ฒ•

์ด ๋ฐฉ๋ฒ•์„ ์‚ฌ์šฉํ•˜๋ฉด ๊ฐœ์ฒด์—์„œ ์ฒ˜์Œ n์ž๋ฅผ ๊ฑด๋„ˆ๋›ธ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค Reader. ํด๋ž˜์Šค ์˜ ์œ ์‚ฌํ•œ ๋ฉ”์„œ๋“œ์™€ ์ •ํ™•ํžˆ ๋™์ผํ•˜๊ฒŒ ์ž‘๋™ํ•ฉ๋‹ˆ๋‹ค InputStream. ์‹ค์ œ๋กœ ๊ฑด๋„ˆ๋›ด ๋ฌธ์ž ์ˆ˜๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

boolean ready()๋ฐฉ๋ฒ•

true์ŠคํŠธ๋ฆผ์— ์ฝ์ง€ ์•Š์€ ๋ฐ”์ดํŠธ๊ฐ€ ์žˆ์œผ๋ฉด ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค .

void close()๋ฐฉ๋ฒ•

๋ฉ”์„œ๋“œ close()๋Š” ๋ฐ์ดํ„ฐ ์ŠคํŠธ๋ฆผ์„ ๋‹ซ๊ณ  ์—ฐ๊ฒฐ๋œ ์™ธ๋ถ€ ๋ฆฌ์†Œ์Šค๋ฅผ ํ•ด์ œํ•ฉ๋‹ˆ๋‹ค. ์ŠคํŠธ๋ฆผ์ด ๋‹ซํžˆ๋ฉด ๋” ์ด์ƒ ๋ฐ์ดํ„ฐ๋ฅผ ์ฝ์„ ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค.

๋น„๊ต๋ฅผ ์œ„ํ•ด ํ…์ŠคํŠธ ํŒŒ์ผ์„ ๋ณต์‚ฌํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

์•”ํ˜ธ ๋ฉ”๋ชจ
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์œ„ํ•ด ํŒŒ์ผ์— ์“ฐ๊ธฐ ์œ„ํ•ด

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

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