-
JAVA ์๋ฐ ์ ์ถ๋ ฅ I/O, ํ์ผ์ฒ๋ฆฌJAVA 2020. 8. 17. 16:48
๐ฏ ์๋ฐ ์ ๋ ฅ๊ณผ ์ถ๋ ฅ, ํ์ผ์ฒ๋ฆฌ๋ฅผ ์์๋ณธ๋ค.
์ ๋ ฅ๊ณผ ์ถ๋ ฅ I/O
ํ๋ก๊ทธ๋จ์์ ์ฝ์ด์ค๋ ๋ชจ๋ ๊ฐ์ ์ธํ ์คํธ๋ฆผ์ด๋ผ๊ณ ํ๋ฉฐ, ๋ฐ์ผ๋ก ์ถ๋ ฅํ๋ ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ์์ํ ์คํธ๋ฆผ์ด๋ผ๊ณ ๋ถ๋ฅธ๋ค. ์คํธ๋ฆผ์ ์๋ฐ์์ ์ฌ์ฉ๊ฐ๋ฅํ ์ฐ์๋ ๋ฐ์ดํฐ ํ๋ฆ์ ๋งํ๋ค.
์ฒ๋ฆฌ ๋ฐ์ดํฐ ์ข ๋ฅ
์ ์ถ๋ ฅ์ผ๋ก ์ฒ๋ฆฌ ๊ฐ๋ฅํ ๋ฐ์ดํฐ๋ byte์ char ๋ ์ข ๋ฅ์ด๋ค. ํ ์คํธ ์์ฃผ์ ๋ฐ์ดํฐ ์ ์ถ๋ ฅ์ char๋ก ์ฒ๋ฆฌํ๋ฉฐ ํ ์คํธ๊ฐ ์๋ ์ด๋ฏธ์ง๊ฐ์ ํ์ผ๋ค์ ๋ค byte๋ก ์ฝ์ด์จ๋ค.
byte
๋ก ์ฒ๋ฆฌํ๋ ํด๋์ค์ ์ต์์ ํด๋์ค๋ InputStream๊ณผ OutputStream์ด๋ค. ํญ์ ์ ๋ ฅ๊ณผ ์ถ๋ ฅ์ ์์ผ๋ก ์ ๊ณต๋๋ฉฐ ๋ ํด๋์ค๋ ์ถ์ํด๋์ค์ด๊ธฐ ๋๋ฌธ์ ์ค์ ๊ตฌํ์ ํ์ ์ผ๋ฐํด๋์ค๊ฐ ๋ด๋นํ๋ค. byte๋ก ์ฒ๋ฆฌํ๋ ํ์ํด๋์ค๋ค์ ์ด๋ฆ์ ๋ณด๋ฉด ๋ค stream์ผ๋ก ๋๋๋ค๋ ํน์ง์ด ์๋ค.char
๋ก ์ฒ๋ฆฌํ๋ ํด๋์ค์ ์ต์์ํด๋์ค๋ ์ ๋ ฅ์ ๋ด๋นํ๋ Reader์ ์ถ๋ ฅ์ ๋ด๋นํ๋ Writer๊ฐ ์๋ค. ์ด ๋ ๊ฐ ์ญ์ ์ถ์ํด๋์ค์ด๋ค. ํ์ํด๋์ค์ ์ด๋ฆ์ด reader ๋๋ writer๋ก ๋๋๋ค๋ ๊ฑธ ์ ์ ์๋ค.ํ์ค์ ์ถ๋ ฅ
์๋ฐ์ ํ์ค์ ๋ ฅ์ ํค๋ณด๋์์ ์ ๋ ฅํ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ด๋ค์ด๋ ์์ ์ ๋งํ๋ฉฐ ํ์ค์ถ๋ ฅ์ ๋ชจ๋ํฐ๋ก ๋ฐ์ดํฐ๋ฅผ ์ถ๋ ฅํ๋ ์์ ์ ์๋ฏธํ๋ค. ํ์ค ์ ์ถ๋ ฅ์ java.lang.System ํด๋์ค๊ฐ ๋ด๋นํ๋ค.
System.in
ํ์ค์ ๋ ฅ์ผ๋ก ํค๋ณด๋์์ ๋ฐ์ดํฐ ์ฝ์ด๋ค์ผ ๋ ์ฌ์ฉํ๋ค. ๋ณ์ in์ ๋ฐ์ดํฐํ์ InputStream์ด๋ค. ๊ธฐ๋ณธ์ ์ผ๋ก ๋ฐ์ดํธ์ฒ๋ฆฌ๋๋ค๋ ์๋ฏธ์ด๋ค.
System.out
ํ์ค์ถ๋ ฅ์ผ๋ก PrintStream์ด out์ ๋ฐ์ดํฐํ์ด๋ค. ์ด ํด๋์ค์ ์ถ๋ ฅ๋ฉ์๋๋ก print์ println ์ค๋ฒ๋ก๋ฉ ๋ฉ์๋๊ฐ ์ ๊ณต๋๋ค.
ํค๋ณด๋ ์ ๋ ฅ์ฒ๋ฆฌ
System.out.println("๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅํ์์ค"); InputStream is = System.in; try { int n = is.read(); System.out.println((char)n); }catch(IOException e) { e.printStackTrace(); }finally { try { if(is!=null) is.close(); }catch (IOException e) { e.getStackTrace(); } }
InputStream.read() ๋ฉ์๋๋ ์ ๋ ฅ๋ ๋ฐ์ดํฐ๋ฅผ 1๋ฐ์ดํธ์ฉ ์ฒ๋ฆฌํ๋ค. hello๋ฅผ ์ ๋ ฅํ์ ๋ h๋ง ์ฝ์ด๋ค์ฌ์ ์์คํค์ฝ๋ ๊ฐ์ ์ถ๋ ฅํ๊ฒ ๋๋ค. ๋ฐ๋ผ์ char๋ก ํ๋ณํ์ ํด์ผํ๋ฉฐ ํ๊ธ์ 2๋ฐ์ดํธ๋ผ ์ถ๋ ฅํ์ง ๋ชปํ๋ ๋นํจ์จ์ ์ธ ์ ๋ ฅ ์ฒ๋ฆฌ ๋ฐฉ์์ด๋ค. ์ ๋ ฅ์คํธ๋ฆผ์ ์ฌ์ฉํ ํ ๋ฐ๋์ close()๋ฉ์๋๋ฅผ ์ฌ์ฉํด ์คํธ๋ฆผ์ ๋ซ์์ผํ๋ค. ์๋ฐ์ I/O๋ ๋ฐ๋์ ์์ธ์ฒ๋ฆฌ๋ฅผ ํด์ผํ๋ค.
InputStreamReader reader = null; try { System.out.println("๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅํ์์ค"); reader = new InputStreamReader(System.in); int n = reader.read(); System.out.println("์ ๋ ฅ๊ฐ: "+(char)n); }catch(IOException e) { e.printStackTrace(); }finally { try { if(reader != null)reader.close(); }catch (IOException e) { e.printStackTrace(); } }
InputStreamReader ํด๋์ค๋ฅผ ์ฌ์ฉํ์ฌ ํค๋ณด๋ ์ ๋ ฅ์ ์ฒ๋ฆฌํ๋ ๋ฐฉ๋ฒ์ด๋ค. char๋ก ์ฒ๋ฆฌํ๊ธฐ ๋๋ฌธ์ ์ฌ๋ฌ ๊ธ์๋ฅผ ์ฝ์ด์ฌ ์ ์์ผ๋ฉฐ ํ๊ธ ์ฒ๋ฆฌ๊ฐ ๊ฐ๋ฅํ๋ค. InputStream์ ์ฒ๋ฆฌ๋ฐฉ์์ธ byte๋ฅผ InputStreamReader์ ์ฒ๋ฆฌ๋ฐฉ์์ธ char๋ก ๋ณ๊ฒฝํ๋ ค๋ฉด ํด๋์ค์ ์์ฑ์ ์ธ์๋ก ์ ๋ฌํ๋ฉด ๋๋ค. ์ฌ์ ํ byte์์ char๋ก ํ๋ณํ์ ํด์ผํ๋ฉฐ ํ ๊ธ์๋ง ์ฒ๋ฆฌํ๊ธฐ ๋๋ฌธ์ ๋๋ฌธ์ ๋นํจ์จ์ ์ธ ์ฒ๋ฆฌ๋ฐฉ์์ด๋ค.
BufferedReader buffer = null; try { System.out.println("๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅํ์์ค"); buffer = new BufferedReader(new InputStreamReader(System.in)); String str = buffer.readLine(); System.out.println("์ ๋ ฅ ๊ฐ: " + str); } catch (IOException e) { e.printStackTrace(); } finally { try { if (buffer != null)buffer.close(); } catch (IOException e) { e.printStackTrace(); } }
BufferedReader ํด๋์ค๋ฅผ ์ถ๊ฐํด์ ํค๋ณด๋ ์ ๋ ฅ์ ์ฒ๋ฆฌํ๋ ๋ฐฉ๋ฒ์ด๋ค. BufferedReader์ ์์ฑ์์ byte์์ char๋ก ๋ณ๊ฒฝํ InputStreamReader๋ฅผ ๋ฃ๋๋ค. ๊ฐ๋จํ char์ฒ๋ฆฌ ๋ฐฉ์์์ ํ์ค์ฉ ์ฝ์ด๋ค์ด๋ ๋จ๊ณ๋ก ์ ๊ทธ๋ ์ด๋ ๋์๋ค. readLine() ๋ฉ์๋๋ ์ ๋ ฅ๋ฐ์ ๋ฐ์ดํฐ๋ฅผ ํ์ค์ฉ ์ฝ๊ธฐ ๋๋ฌธ์ ์ ๋ฐฉ๋ฒ๋ณด๋ค ๋ ํจ์จ์ ์ผ๋ก ์ ๋ ฅ์ฒ๋ฆฌ๋ฅผ ํ ์ ์๋ค.
ํค๋ณด๋ ์ ๋ ฅ ์ฒ๋ฆฌ๋ Scanner ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ฉด ๋ ์ฝ๋ค.
์๋ฐ์ ์ ์ถ๋ ฅ์ฒ๋ฆฌ๋ฅผ ๋ด๋นํ๋ ํด๋์ค
Node ๊ณ์ด
byte๋ char๋ก ๊ฐ๊ณต๋์ง ์์ ์์๋ฐ์ดํฐ๋ฅผ ์ง์ ์ฒ๋ฆฌํ๋ ํด๋์ค ๊ณ์ด์ด๋ค. ์ ์ถ๋ ฅ์ ์์ ํด๋์ค๋ค์ธ InputStream, OutputStream, Reader, Writer๊ฐ ์ฌ๊ธฐ ์ํ๋ฉฐ ๋นํจ์จ์ ์ผ๋ก ์ ์ถ๋ ฅํ๋ค๋ ๊ฒ์ด ํน์ง์ด๋ค. ์ฝ์์ ์ด์ฉํ ๋ ๋ ธ๋๊ณ์ด์ ์ฌ์ฉํ๋ค.
Filter ๊ณ์ด
๋ ธ๋ ๊ณ์ด์์ ํจ์จ์ ์ธ ๋ฐ์ดํฐ ์ฒ๋ฆฌ๋ฅผ ์ํด ์ถ๊ฐํ ์ ์๋ ํด๋์ค ๊ณ์ด์ด๋ค. InputStreamReader๊ณผ BufferedReader, PrintWriter ํด๋์ค๊ฐ ํด๋น๋๋ค.
ํ์ผ ์ฒ๋ฆฌ
File ํด๋์ค๋ ํ์ผ๊ณผ ๋๋ ํ ๋ฆฌ์ ๊ดํ ๋ฉํ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๋ ํด๋์ค์ด๋ค. ํ์ผ๋ช , ๋๋ ํ ๋ฆฌ๋ช , ํ์ผํฌ๊ธฐ, ์ฝ๊ธฐ๋ชจ๋,์ฐ๊ธฐ๋ชจ๋, ๋๋ ํ ๋ฆฌ ์ ๋ณด, ํ์ผ์ญ์ , ๋๋ ํ ๋ฆฌ ์์ฑ ๋ฑ์ ์์ ์ ๋ด๋นํ๋ค.
new File("๋๋ ํ ๋ฆฌ"); new File("ํ์ผ๋ช "); new File("๋๋ ํ ๋ฆฌ/ํ์ผ๋ช "); new File("๋๋ ํ ๋ฆฌ","ํ์ผ๋ช ");
File ํด๋์ค์ ์์ฑ์์ ๋ค์๊ณผ ๊ฐ์ด ํ์ผ๋ช , ๋๋ ํ ๋ฆฌ ๊ฐ์ฒด, ํ์ผ๊ฒฝ๋ก๋ฅผ ์ฌ์ฉํ์ฌ ๋ฉํ์ ๋ณด๋ฅผ ์์๋ณด๊ธฐ ์ํ ๊ฐ์ฒด๋ฅผ ์์ฑํ ์ ์๋ค.
File f = new File("c:\\Test","IOTest.java"); System.out.println("ํ์ผํฌ๊ธฐ: "+ f.length()); System.out.println("ํ์ผ์ด๋ฆ: "+ f.getName()); System.out.println("ํ์ผ๊ฒฝ๋ก: "+ f.getPath()); System.out.println("ํ์ผ์ ๋๊ฒฝ๋ก: "+ f.getAbsolutePath()); System.out.println("ํ์ผ์ด๋?: "+ f.isFile()); System.out.println("๋๋ ํ ๋ฆฌ์ด๋?: "+ f.isDirectory()); System.out.println("ํ์ผ์ด ์กด์ฌ? "+ f.exists()); System.out.println("์คํ๊ฐ๋ฅํ๋: "+ f.canExecute()); System.out.println("write ๊ฐ๋ฅ?: "+ f.canWrite()); System.out.println("read ๊ฐ๋ฅ?: "+ f.canRead()); //System.out.println(f.delete());
์์๊ฐ์ด File ํด๋์ค์ ๋ฉ์๋๋ฅผ ์ฌ์ฉํด ๋ฉํ์ ๋ณด๋ฅผ ์ถ๋ ฅํ ์ ์๋ค.
ํ์ผ ์ ์ถ๋ ฅ
์ผ๋ฐ txt ํ์ผ์ ์ ๊ทผํ ๋ char ๋จ์๋ก ์ฒ๋ฆฌํ๋ ๊ฒ ํจ์จ์ ์ด๊ธฐ ๋๋ฌธ์ FileReader ๋ฐ FileWriter ๊ฐ์ Node๊ณ์ด ํด๋์ค๋ฅผ ์ฌ์ฉํด ์ฒ๋ฆฌํ ์ ์๋ค. ์ฌ๊ธฐ์ BufferedReader์ PrintWriter์ ๊ฐ์ Filter ๊ณ์ด ํด๋์ค๋ฅผ ์ถ๊ฐํด์ ๊ตฌํํ๋ฉด ๋ ํจ์จ์ ์ธ ํ์ผ ์ ์ถ๋ ฅ์ด ๊ฐ๋ฅํ๋ค.
์ด๋ฏธ์ง ํ์ผ๊ณผ ๊ฐ์ ๋ฐ์ด๋๋ฆฌ ํ์ผ์ ์ ๊ทผํ ๋ byte ๋จ์๋ก๋ง ์ฒ๋ฆฌ๋๋ FileInputStream๊ณผ FileOutputStream์ ์ฌ์ฉํ๋ค.
FileWriter์ ์ฌ์ฉํ ํ ์คํธ ํ์ผ ์ ์ฅ
C๋๋ผ์ด๋ธ Test ํด๋์ ๋น xyz ํ ์คํธ ํ์ผ์ ๋ง๋ค์๋ค.
File f = new File("C:\\Test\\xyz.txt"); PrintWriter out = null; try { FileWriter writer = new FileWriter(f, true); // ํํฐ out = new PrintWriter(writer); out.print("happy"); // out.flush(); } catch (IOException e) { e.printStackTrace(); } finally { out.close(); }
File ํด๋์ค ๊ฐ์ฒด๋ฅผ ์์ฑํ๋ค. ์ง์ ํ xyz.txt ํ์ผ์ด ์กด์ฌํ์ง ์์ผ๋ฉด ์๋์ผ๋ก ํ์ผ์ ์์ฑํ๋ค. FileWriter ์์ฑ์์ ๋๋ฒ์งธ ์ธ์๊ฐ์ผ๋ก true๋ฅผ ์ ์ผ๋ฉด ํ์ผ์ ๋ด์ฉ์ด ์๋ก ์ถ๊ฐ๋๋ ๋ฐฉ์์ผ๋ก ๋์ํ๋ฉฐ false๋ ๋ฎ์ด์ฐ๊ธฐ ๋ฐฉ์์ผ๋ก ๋์ํ๋ค. ํจ์จ์ ์ธ ๋ฐ์ดํฐ ์ถ๋ ฅ์ ์ํด Filter ๊ณ์ด์ธ PrintWriter ๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ๋ค. ์ฝ๋๋ฅผ ์คํํ๊ณ xyz.txt ํ์ผ์ ํ์ธํด๋ณด๋ฉด "happy"๊ฐ ์ถ๊ฐ๋ ๊ฒ์ ๋ณผ ์ ์๋ค.
FileInputStream๊ณผ FileOutputStream์ ์ฌ์ฉํด ์ด๋ฏธ์ง ๋ณต์ฌํ๊ธฐ
FileInputStream fis = null; FileOutputStream fos = null; try { File readFile = new File("c:\\Test", "a.jpg"); File writeFile = new File("c:\\Test", "b.jpg"); int size = (int)readFile.length(); byte[] readByte = new byte[size]; fis = new FileInputStream(readFile); fos = new FileOutputStream(writeFile); int n = fis.read(readByte); fos.write(readByte); }catch (Exception e) { e.printStackTrace(); }finally { try { fis.close(); fos.close(); }catch(IOException e) { e.printStackTrace(); } }
ํ์ผ ๊ฒฝ๋ก์ ํ์ผ๋ช ์ ์ด์ฉํด ํ์ผ ๊ฐ์ฒด๋ฅผ ์์ฑํ ๋ค ํ์ผ ์ฌ์ด์ฆ์ ํฌ๊ธฐ๋งํผ byte ๋ฐฐ์ด์ ์์ฑํ๋ค. ์ด๋ฏธ์ง ํ์ผ์ ์ฝ๊ณ ์ถ๋ ฅํ ์ ์๋๋ก byte์ฒ๋ฆฌ๋ฅผ ๋ด๋นํ๋ FileInputStream๊ณผ FileOutputStream ๊ฐ์ฒด๋ฅผ ์์ฑํ๋ค. ์ด๋ฏธ์ง ํ์ผ์ ์ฝ๊ณ ๋ฐฐ์ด์ ์ ์ฅํ๋ค. write() ๋ฉ์๋๋ก ๋ฐฐ์ด์ ์ ์ฅ๋ ๋ฐ์ดํฐ๋ฅผ ์ถ๋ ฅํ๋ค. ๋ชจ๋ ์์ ์ด ๋๋๋ฉด close()๋ก ๋ซ์์ค๋ค.
๐ NEXT : JDBC ์ฌ์ฉํ๊ธฐ
๋ฐ์ํ'JAVA' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
JAVA ์๋ฐ JDBC ๋ฌธ์ ์ฐ์ต (0) 2020.08.19 JAVA ์๋ฐ JDBC ์ค๋ผํด DB ์ฐ๋ (0) 2020.08.18 JAVA ์๋ฐ ํต์ฌํด๋์ค (0) 2020.08.16 JAVA ์๋ฐ Object ํด๋์ค equals(), toString() (0) 2020.08.15 JAVA ์๋ฐ Map ๋งต HashMap (0) 2020.08.15