โถ byte ๋จ์ ์คํธ๋ฆผ
โ
*InputStream
byte ๋จ์๋ก ์ฝ๋ ์คํธ๋ฆผ ์ค ์ต์์ ์คํธ๋ฆผ์ด๋ค.
InputStream์ ์ถ์ ๋ฉ์๋๋ฅผ ํฌํจํ ์ถ์ ํด๋์ค๋ก์ ํ์ ์คํธ๋ฆผ ํด๋์ค๊ฐ ์์๋ฐ์ ๊ฐ ํด๋์ค ์ญํ ์ ๋ง๊ฒ ์ถ์ ๋ฉ์๋ ๊ธฐ๋ฅ์ ๊ตฌํํ๋ค.
โ
โ
โ
*InputStream์ด ์ฃผ๋ก ์ฌ์ฉํ๋ ํ์ ํด๋์ค
์คํธ๋ฆผ ํด๋์ค |
์ค๋ช |
FileInputStream |
ํ์ผ์์ ๋ฐ์ดํธ ๋จ์๋ก ์๋ฃ๋ฅผ ์ฝ๋๋ค. |
ByteArrayInputStream |
Byte ๋ฐฐ์ด ๋ฉ๋ชจ๋ฆฌ์์ ๋ฐ์ดํธ ๋จ์๋ก ์๋ฃ๋ฅผ ์ฝ๋๋ค. |
FilterInputStream |
๊ธฐ๋ฐ ์คํธ๋ฆผ์์ ์๋ฃ๋ฅผ ์ฝ์ ๋ ์ถ๊ฐ ๊ธฐ๋ฅ์ ์ ๊ณตํ๋ ๋ณด์กฐ ์คํธ๋ฆผ์ ์์ ํด๋์ค์ด๋ค. (๋ณด์กฐ ์คํธ๋ฆผ์ '15-5 ๋ณด์กฐ ์คํธ๋ฆผ'์์ ์์ธํ ์ค๋ช ํ๋ค.) |
โ
InputStream์ byte ์๋ฃ๋ฅผ ์ฝ๊ธฐ ์ํด ๋ค์ ๋ฉ์๋๋ฅผ ์ ๊ณตํ๋ค.
๋ฉ์๋ |
์ค๋ช |
int read( ) |
์ ๋ ฅ ์คํธ๋ฆผ์ผ๋ก๋ถํฐ ํ byte์ ์๋ฃ๋ฅผ ์ฝ๋๋ค. ์ฝ์ ์๋ฃ์ byte ์๋ฅผ ๋ฐํํ๋ค. |
int read(byte b[ ]) |
์ ๋ ฅ ์คํธ๋ฆผ์ผ๋ก๋ถํฐ b[ ] ํฌ๊ธฐ์ ์๋ฃ๋ฅผ b[ ]์ ์ฝ๋๋ค. ์ฝ์ ์๋ฃ์ byte ์๋ฅผ ๋ฐํํ๋ค. |
int read(byte b[ ], int off, int len) |
์ ๋ ฅ ์คํธ๋ฆผ์ผ๋ก๋ถํฐ b[ ] ํฌ๊ธฐ์ ์๋ฃ๋ฅผ b[ ]์ off ๋ณ์ ์์น๋ก๋ถํฐ ์ ์ฅํ๋ฉฐ len๋งํผ ์ฝ๋๋ค. ์ฝ์ ์๋ฃ์ byte ์๋ฅผ ๋ฐํํ๋ค. |
void close( ) |
์ ๋ ฅ ์คํธ๋ฆผ๊ณผ ์ฐ๊ฒฐ๋ ๋์ ๋ฆฌ์์ค๋ฅผ ๋ซ๋๋ค. (์ : FileInputStream์ธ ๊ฒฝ์ฐ ํ์ผ ๋ซ์) |
โ
โ
โ
*FileInputStream
FileInputStream์ ํ์ผ์์ byte ๋จ์๋ก ์๋ฃ๋ฅผ ์ฝ์ด ๋ค์ผ ๋ ์ฌ์ฉํ๋ ์คํธ๋ฆผ ํด๋์ค์ด๋ค. ์คํธ๋ฆผ์ ์ฌ์ฉํ๊ธฐ ์ํด์๋ ๋จผ์ ์คํธ๋ฆผ ํด๋์ค๋ฅผ ์์ฑํด์ผ ํ๋ค.
์์ฑ์ |
์ค๋ช |
FileInputStream(String name) |
ํ์ผ ์ด๋ฆ name(๊ฒฝ๋ก ํฌํจ)์ ๋งค๊ฐ๋ณ์๋ก ๋ฐ์ ์ ๋ ฅ ์คํธ๋ฆผ์ ์์ฑํ๋ค. |
FileInputStream(File f) |
File ํด๋์ค ์ ๋ณด๋ฅผ ๋งค๊ฐ๋ณ์๋ก ๋ฐ์ ์ ๋ ฅ ์คํธ๋ฆผ์ ์์ฑํ๋ค. |
โ
โ
FileInputStreamTest1.java
package stream.inputstream;
import java.io.FileInputStream;
import java.io.IOException;
public class FileInputStreamTest1 {
public static void main(String[] args) {
FileInputStream fis = null;
try {
fis = new FileInputStream("input.txt"); // input.txt ํ์ผ ์
๋ ฅ ์คํธ๋ฆผ ์์ฑ
System.out.println((char)fis.read());
System.out.println((char)fis.read());
System.out.println((char)fis.read());
} catch (IOException e) {
System.out.println(e);
} finally {
try {
fis.close(); // ์ด๋ฆฐ ์คํธ๋ฆผ์ finally ๋ธ๋ก์์ ๋ซ์
} catch (IOException e) {
System.out.println(e);
} catch (NullPointerException e) { // ์คํธ๋ฆผ์ด null์ธ ๊ฒฝ์ฐ
System.out.println(e);
}
}
System.out.println("end");
}
}
โ<์คํ ๊ฒฐ๊ณผ>
โ
โ
โโ
-ํ์ผ์์ ์๋ฃ ์ฝ๊ธฐ
โ
1. input.txt๋ฅผ ๋ง๋ค์ด์ค๋ค.
โ
โ
2. ABC๋ฅผ ์ ๋ ฅํ๊ณ ์ ์ฅํ๋ค.
โ
โ
3. FileInputStreamTest1 ํด๋์ค๋ก ๋์๊ฐ์ ๋ค์ ์คํ์์ผ๋ณธ๋ค.
โ
4. ๋ฌธ์์ด๋ก ์ถ๋ ฅํ๋ ค๋ฉด ๋ค์์ฒ๋ผ char ์๋ฃํ์ผ๋ก ๋ณํํ๋ค.
โ
โ
-ํ์ผ ๋๊น์ง ์ฝ๊ธฐ
โ
FileInputStreamTest2.java
package stream.inputstream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class FileInputStreamTest2 {
public static void main(String[] args) {
try (FileInputStream fis = new FileInputStream("reader.txt")) {
int i;
while ((i = fis.read()) != -1) { // i ๊ฐ์ด -1์ด ์๋ ๋์ read() ๋ฉ์๋๋ก ํ ๋ฐ์ดํธ๋ฅผ ๋ฐ๋ณตํด์ ์ฝ์
System.out.println((char) i);
}
System.out.println("end");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
<์คํ ๊ฒฐ๊ณผ>
โ
โ
-int read(byte[] b) ๋ฉ์๋๋ก ์ฝ๊ธฐ
์๋ฃ๋ฅผ read( ) ๋ฉ์๋๋ก ํ ๋ฐ์ดํธ์ฉ ์ฝ๋ ๊ฒ๋ณด๋ค ๋ฐฐ์ด์ ์ฌ์ฉํ์ฌ ํ๊บผ๋ฒ์ ๋ง์ด ์ฝ์ผ๋ฉด ์ฒ๋ฆฌ ์๋๊ฐ ํจ์ฌ ๋น ๋ฅด๋ค. read(byte[ ] b) ๋ฉ์๋๋ ์ ์ธํ ๋ฐ์ดํธ ๋ฐฐ์ด์ ํฌ๊ธฐ๋งํผ ํ๊บผ๋ฒ์ ์๋ฃ๋ฅผ ์ฝ๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ฝ์ด ๋ค์ธ ์๋ฃ์ ์๋ฅผ ๋ฐํํ๋ค.
โ
1. input2.txt๋ฅผ ๋ง๋ค๊ณ 'A~Z'๊น์ง ์ ๋ ฅํ ํ ์ ์ฅํ๋ค.
โ
โ
2. byte ๋ฐฐ์ด๋ก ์ฝ๋ ์์ค์ฝ๋ ์์ฑํ๊ธฐ
package stream.inputstream;
import java.io.FileInputStream;
import java.io.IOException;
public class FileInputStreamTest3 {
public static void main(String[] args) {
try (FileInputStream fis = new FileInputStream("input2.txt")) {
byte[] bs = new byte[10];
int i;
while ((i = fis.read(bs)) != -1) {
for (byte b : bs) { // byte ๋ฐฐ์ด๋ก ์ฝ์
System.out.print((char)b);
}
System.out.println(": " + i + "๋ฐ์ดํธ ์ฝ์");
}
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("end");
}
}
โ<์คํ ๊ฒฐ๊ณผ>
โ
โ
โ
-์ ์ฒด ๋ฐฐ์ด์ ์ถ๋ ฅํ์ง์๊ณ ์ ๋ ฅํ byte ์๋งํผ, ์ฆ i ๊ฐ์๋งํผ ์ถ๋ ฅํ๋๋ก ํ ๋
package stream.inputstream;
import java.io.FileInputStream;
import java.io.IOException;
public class FileInputStreamTest3 {
public static void main(String[] args) {
try (FileInputStream fis = new FileInputStream("input2.txt")) {
byte[] bs = new byte[10];
int i;
while ((i = fis.read(bs)) != -1) {
for (int k = 0; k < i; k++) { // ์
๋ ฅํ byte ์๋งํผ ์ถ๋ ฅ
System.out.print((char)bs[k]);
}
System.out.println(": " + i + "๋ฐ์ดํธ ์ฝ์");
}
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("end");
}
}
โ<์คํ ๊ฒฐ๊ณผ>
โ
โ
โ
*OutputStream
byte ๋จ์๋ก ์ฐ๋ ์คํธ๋ฆผ ์ค ์ต์์ ์คํธ๋ฆผ์ด๋ค. ์๋ฃ์ ์ถ๋ ฅ ๋์์ ๋ฐ๋ผ ๋ค๋ฅธ ์คํธ๋ฆผ์ ์ ๊ณตํ๋ค.
์คํธ๋ฆผ ํด๋์ค |
์ค๋ช |
FileOutputStream |
๋ฐ์ดํธ ๋จ์๋ก ํ์ผ์ ์๋ฃ๋ฅผ ์ด๋ค. |
ByteArrayOutputStream |
byte ๋ฐฐ์ด์ ๋ฐ์ดํธ ๋จ์๋ก ์๋ฃ๋ฅผ ์ด๋ค. |
FilterOutputStream |
๊ธฐ๋ฐ ์คํธ๋ฆผ์์ ์๋ฃ๋ฅผ ์ธ ๋ ์ถ๊ฐ ๊ธฐ๋ฅ์ ์ ๊ณตํ๋ ๋ณด์กฐ ์คํธ๋ฆผ์ ์์ ํด๋์ค์ด๋ค. |
โ
OutputStream์์ ์ ๊ณตํ๋ ๋ฉ์๋๋ ๋ค์๊ณผ ๊ฐ๋ค.
๋ฉ์๋ |
์ค๋ช |
void write(int b) |
ํ ๋ฐ์ดํธ๋ฅผ ์ถ๋ ฅํ๋ค. |
void write(byte[ ] b) |
b[ ] ๋ฐฐ์ด์ ์๋ ์๋ฃ๋ฅผ ์ถ๋ ฅํ๋ค. |
void write(byte b[ ], int off, int len) |
b[ ] ๋ฐฐ์ด์ ์๋ ์๋ฃ์ off ์์น๋ถํฐ len ๊ฐ์๋งํผ ์๋ฃ๋ฅผ ์ถ๋ ฅํ๋ค. |
void flush( ) |
์ถ๋ ฅ์ ์ํด ์ ์ ์๋ฃ๊ฐ ๋จธ๋ฌด๋ฅด๋ ์ถ๋ ฅ ๋ฒํผ๋ฅผ ๊ฐ์ ๋ก ๋น์ ์๋ฃ๋ฅผ ์ถ๋ ฅํ๋ค. |
void close( ) |
์ถ๋ ฅ ์คํธ๋ฆผ๊ณผ ์ฐ๊ฒฐ๋ ๋์ ๋ฆฌ์์ค๋ฅผ ๋ซ๋๋ค. ์ถ๋ ฅ ๋ฒํผ๊ฐ ๋น์์ง๋ค. (์ : FileOutputStream์ธ ๊ฒฝ์ฐ ํ์ผ ๋ซ์) |
โ
โ
โโ
*FileOutputStream
ํ์ผ์ byte ๋จ์ ์๋ฃ๋ฅผ ์ถ๋ ฅํ๊ธฐ์ํด ์ฌ์ฉํ๋ ์คํธ๋ฆผ์ด๋ค.
OutputStream์ ์์๋ฐ์ ํด๋์ค ์ค ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉํ๋ค.
์์ฑ์ |
์ค๋ช |
FileOutputStream(String name) |
ํ์ผ ์ด๋ฆ name(๊ฒฝ๋ก ํฌํจ)์ ๋งค๊ฐ๋ณ์๋ก ๋ฐ์ ์ถ๋ ฅ ์คํธ๋ฆผ์ ์์ฑํ๋ค. |
FileOutputStream(String name, boolean append) |
ํ์ผ ์ด๋ฆ name(๊ฒฝ๋ก ํฌํจ)์ ๋งค๊ฐ๋ณ์๋ก ๋ฐ์ ์ ๋ ฅ ์คํธ๋ฆผ์ ์์ฑํ๋ค. append ๊ฐ์ด true์ด๋ฉด ํ์ผ ์คํธ๋ฆผ์ ๋ซ๊ณ ๋ค์ ์์ฑํ ๋ ํ์ผ์ ๋์ ์ด์ด์ ์ด๋ค. ๋ํดํธ ๊ฐ์ false์ด๋ค. |
FileOutputStream(File f, ) |
File ํด๋์ค ์ ๋ณด๋ฅผ ๋งค๊ฐ๋ณ์๋ก ๋ฐ์ ์ถ๋ ฅ ์คํธ๋ฆผ์ ์์ฑํ๋ค. |
FileOutputStream(Filen f, boolean append) |
File ํด๋์ค ์ ๋ณด๋ฅผ ๋งค๊ฐ๋ณ์๋ก ๋ฐ์ ์ถ๋ ฅ ์คํธ๋ฆผ์ ์์ฑํ๋ค. append ๊ฐ์ด true์ด๋ฉด ํ์ผ ์คํธ๋ฆผ์ ๋ซ๊ณ ๋ค์ ์์ฑํ ๋ ํ์ผ์ ๋์ ์ด์ด์ ์ด๋ค. ๋ํดํธ ๊ฐ์ false์ด๋ค. |
์์ฑ์ ๋งค๊ฐ๋ณ์๋ก ์ ๋ฌํ ํ์ผ์ด ๊ฒฝ๋ก์ ์์ผ๋ฉด FileOutputStream์ ํ์ผ์ ์๋ก ์์ฑํ๋ค. FileOutStream์ ์ฌ์ฉํด ํ์ผ์ ์๋ฃ๋ฅผ ์ธ ๋ ๊ธฐ์กด ํ์ผ์ ๋ด์ฉ์ด ์๋๋ผ๋ ์ฒ์๋ถํฐ ์๋ก ์ธ์ง(overwrite), ์๋๋ฉด ๊ธฐ์กด ๋ด์ฉ ๋งจ ๋ค์ ์ฐ๊ฒฐํด์ ์ธ ๊ฒ์ธ์ง(append) ์ฌ๋ถ๋ฅผ FileOutStream ์์ฑ์์ ๋งค๊ฐ๋ณ์๋ก ์ ๋ฌํ๋ค. ์ด ๊ฐ์ด append ๋ณ์์ด๋ค. ์คํธ๋ฆผ ์์ฑ์์์ append ๊ฐ์ ๋ํดํธ๊ฐ false์ด๋ค. ๊ธฐ์กด์ ์ฐ์ฌ ์๋ ๋ด์ฉ์ด ์๋๋ผ๋ ์๋ก ์ด๋ค. ๊ธฐ์กด ํ์ผ ๋ด์ฉ์ ์ด์ด์ ์จ์ผ ํ๋ค๋ฉด append ๊ฐ์ ๋ฐ๋์ true๋ก ์ง์ ํ๋ค.
โ
โ
โโ
-write( ) ๋ฉ์๋ ์ฌ์ฉํ๊ธฐ
โ
1. output.txt ๋นํ์ผ ๋ง๋ค๊ธฐ
โ
2.
package stream.outputstream;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamTest {
public static void main(String[] args) {
try (FileOutputStream fos = new FileOutputStream("output.txt")) {
fos.write(65);
fos.write(66);
fos.write(67); // FileOutputStream์ ํ์ผ์ ์ซ์๋ฅผ ์ฐ๋ฉด ํด๋นํ๋ ์์คํค ์ฝ๋ ๊ฐ์ผ๋ก ๋ณํ๋จ
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("์ถ๋ ฅ์ด ์๋ฃ๋์์ต๋๋ค.");
}
}
<์คํ ๊ฒฐ๊ณผ>
โ
โ
โโ
-write(byte[ ] b) ๋ฉ์๋ ์ฌ์ฉํ๊ธฐ
์ถ๋ ฅ๋ ์ ๋ ฅ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ์ฌ๋ฌ ์๋ฃ๋ฅผ ํ๊บผ๋ฒ์ ์ถ๋ ฅํ๋ฉด ํจ์จ์ ์ผ๋ฟ๋๋ฌ ์คํ ์๊ฐ๋ ์ค์ด๋ ๋ค. ๋ฐ๋ผ์ byte ๋ฐฐ์ด์ ํ์ฉํ์ฌ ์ถ๋ ฅํ ์ ์๋ค. write(byte[ ] b) ๋ฉ์๋๋ byte ๋ฐฐ์ด์ ์๋ ์๋ฃ๋ฅผ ํ๊บผ๋ฒ์ ์ถ๋ ฅํ๋ค.
โ
1. output2.txt ๋นํ์ผ ๋ง๋ค๊ธฐ
โ
2.
package stream.outputstream;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamTest2 {
public static void main(String[] args) {
try (FileOutputStream fos = new FileOutputStream("output2.txt", true)) {
byte[] bs = new byte[26];
byte data = 65; // 'A'์ ์์คํค ๊ฐ
for (int i = 0; i < bs.length; i++) { // A๋ถํฐ Z๊น์ง ๋ฐฐ์ด์ ๋ฃ๊ธฐ
bs[i] = data;
data++;
}
fos.write(bs); // ๋ฐฐ์ด์ ํ๊บผ๋ฒ์ ์ถ๋ ฅ
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("์ถ๋ ฅ์ด ์๋ฃ๋์์ต๋๋ค.");
}
}
โ<์คํ ๊ฒฐ๊ณผ>
โ
โ
โ
โ
-write(byte[ ] b, int off, int len) ๋ฉ์๋ ์ฌ์ฉํ๊ธฐ
write(byte[ ] b, int off, int len) ๋ฉ์๋๋ ๋ฐฐ์ด์ ์ ์ฒด ์๋ฃ๋ฅผ ์ถ๋ ฅํ์ง ์๊ณ ๋ฐฐ์ด์ off ์์น๋ถํฐ len ๊ธธ์ด๋งํผ ์ถ๋ ฅํ๋ค.
โโ
1. output3.txt ๋นํ์ผ ๋ง๋ค๊ธฐ
โ
2.
package stream.outputstream;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamTest3 {
public static void main(String[] args) {
try (FileOutputStream fos = new FileOutputStream("output3.txt", true)) {
byte[] bs = new byte[26];
byte data = 65; // 'A'์ ์์คํค ๊ฐ
for (int i = 0; i < bs.length; i++) {
bs[i] = data;
data++;
}
fos.write(bs, 2, 10); // ๋ฐฐ์ด์ ์ธ ๋ฒ์งธ ์์น๋ถํฐ 10๊ฐ ๋ฐ์ดํธ ์ถ๋ ฅ
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("์ถ๋ ฅ์ด ์๋ฃ๋์์ต๋๋ค.");
}
}
<์คํ ๊ฒฐ๊ณผ>
โ
โ
โ
โ
*flush( ) ๋ฉ์๋์ close( ) ๋ฉ์๋
์ถ๋ ฅ ์คํธ๋ฆผ์์ flush( ) ๋ฉ์๋์ ๊ธฐ๋ฅ์ ๊ฐ์ ๋ก ์๋ฃ๋ฅผ ์ถ๋ ฅํ๋ ๊ฒ์ด๋ค. write( ) ๋ฉ์๋๋ก ๊ฐ์ ์ผ๋ค๊ณ ํด๋ ๋ฐ๋ก ํ์ผ์ด๋ ๋คํธ์ํฌ๋ก ์ ์ก๋์ง ์๊ณ ์ถ๋ ฅ์ ์ํ ์๋ฃ๊ฐ ์์ด๋ ์ถ๋ ฅ ๋ฒํผ์ ์ด๋ ์ ๋ ์๋ฃ๊ฐ ๋ชจ์ฌ์ผ ์ถ๋ ฅ๋๋ค. ๋ฐ๋ผ์ ์๋ฃ์ ์์ด ์ถ๋ ฅํ ๋งํผ ๋ง์ง ์์ผ๋ฉด write( ) ๋ฉ์๋๋ก ์ถ๋ ฅํ์ด๋ ํ์ผ์ ์ฐ์ด์ง ์๊ฑฐ๋ ์ ์ก๋์ง ์์ ์ ์๋ค. ์ด๋ฐ ๊ฒฝ์ฐ์ flush( ) ๋ฉ์๋๋ฅผ ํธ์ถํ๋ค. ์ถ๋ ฅ ์คํธ๋ฆผ์ close( ) ๋ฉ์๋ ์์์ flush( ) ๋ฉ์๋๋ฅผ ํธ์ถํ์ฌ ์ถ๋ ฅ ๋ฒํผ๊ฐ ๋น์์ง๋ฉด์ ๋จ์ ์๋ ์๋ฃ๊ฐ ๋ชจ๋ ์ถ๋ ฅ๋๋ค.
'Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java-๊ธฐ์ด] ๋ณด์กฐ ์คํธ๋ฆผ (0) | 2021.02.23 |
---|---|
[Java-๊ธฐ์ด] ๋ฌธ์ ๋จ์ ์คํธ๋ฆผ (0) | 2021.02.23 |
[Java-๊ธฐ์ด] ๊ทธ ์ธ ์ ๋ ฅ ํด๋์ค (0) | 2021.02.22 |
[Java-๊ธฐ์ด] ํ์ค ์ ์ถ๋ ฅ (0) | 2021.02.22 |
[Java-๊ธฐ์ด] ์๋ฐ ์ ์ถ๋ ฅ (Stream) (0) | 2021.02.22 |
๋๊ธ