์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | 5 | 6 | 7 |
8 | 9 | 10 | 11 | 12 | 13 | 14 |
15 | 16 | 17 | 18 | 19 | 20 | 21 |
22 | 23 | 24 | 25 | 26 | 27 | 28 |
29 | 30 | 31 |
- join
- ๋ ผ๋ฆฌ ์ฐ์ฐ์
- ์์ฝ์ด
- ์๋ณ์
- ์ค๋ฒ๋ก๋ฉ
- ๋น๊ต ์ฐ์ฐ์
- ์ฐ์ฐ์
- java
- StringBuffer
- SQL
- SQLํ๋
- ๊ฐ์ฒด์งํฅ
- ์ค๋ฒ๋ผ์ด๋ฉ
- ์ฐ์ ์ฐ์ฐ์
- ๋ฐฐ์ด
- ์น์ ํ SQL
- ๊ฐ์ฒด
- ์คํ๋ง์ํ๋ฆฌํฐ ๋ก๊ทธ์์
- ํจ์
- ์์
- ์๋ฐ์์ ์
- @PreAuthorize("isAuthenticated()")
- ๋ฐ๋ณต๋ฌธ
- SpringSecurity ๋ก๊ทธ์ธ
- ์น์ ํ SQL ํ๋
- SQL ํ๋
- ์ธํ ๋ฆฌ์ ์ด Web ์ ํ๋ฆฌ์ผ์ด์
- SpringSecurity ๋ก๊ทธ์์
- spring ๊ฒ์ํ ์ญ์
- ์ดํด๋ฆฝ์ค ์ค์น
- Today
- Total
gi_dor
Java I / O ๋ณธ๋ฌธ
๐ธ I / O - Java์ ์ ๋ ฅ , ์ถ๋ ฅ
- Input ์ ๋ ฅ , Output ์ถ๋ ฅ
- java.io ํจํค์ง์ ํด๋์ค
- ์ ํ๋ฆฌ์ผ์ด์ ์์ ๋ฆฌ์์ค๋ฅผ ์ฝ๊ฑฐ๋ ์ ํ๋ฆฌ์ผ์ด์ ์ ๋ฐ์ดํฐ๋ฅผ ์ถ๋ ฅํ๋ ์์ ์ ์ํํ๋ ํด๋์ค
InputStream / Reader = ์ฝ๊ธฐ
OutputStream / Writer = ์ฐ๊ธฐ
โป 1byte ์ฉ ์ฝ๊ณ ์ด๋ค : InputStream / OutputStream ( ํ ์คํธ , ์ฌ์ง , ์์ , ์์ถํ์ผ )
โป 1 ๊ธ์์ฉ ์ฝ๊ณ ์ด๋ค : Reader / Writer ( ํ ์คํธ ๋ง )
๐น ์คํธ๋ฆผ ( = ํ์ดํ )
- ์ด๋ ํ์ชฝ์์ ๋ค๋ฅธ์ชฝ์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ ๋ฌํ๋ ค๋ฉด ๋ ๋์์ ์ฐ๊ฒฐํ๋ ์คํธ๋ฆผ์ด ํ์ํ๋ค
- ์คํธ๋ฆผ์ ๋ฐ์ดํฐ๋ฅผ ์ด๋ฐํ๋๋ฐ ์ฌ์ฉ๋๋ ์ฐ๊ฒฐํต๋ก
- ์คํธ๋ฆผ์ '๋จํฅํต์ ' ๋ง ๊ฐ๋ฅํ๊ธฐ์ ์ ๋ ฅ๊ณผ ์ถ๋ ฅ์ ๋์์ ์ฒ๋ฆฌ ํ ์ ์๋ค ( โ ๋ถ๊ฐ )
- ์ ๋ ฅ ์คํธ๋ฆผ , ์ถ๋ ฅ ์คํธ๋ฆผ 2๊ฐ์ ์คํธ๋ฆผ์ด ํ์ํ๋ค
- Queue ์ ๊ฐ์ FIFO ๊ตฌ์กฐ๋ก ๋์ด์๋ค.
๐ ์คํธ๋ฆผ์๋ ์คํธ๋ฆผ์ ์ฐ๊ฒฐํ๋ ๋ฐ์ฝ๋ ์ดํฐํจํด , ์ฌ๋ฌ๊ฐ์ ์คํธ๋ฆผ์ ์ฐ๊ฒฐํ๋ ๊ฒ๋ ๊ฐ๋ฅํ๋ค
โ ์ฑ๋ฅ์ด ๋ ์ข์์ง๋ค๊ณ ํ๋ค
๐น ByteStream
- ์คํธ๋ฆผ ๊ฐ์ฒด๋ก ํ๋ฒ์ 1 byte ์ฉ ์ฝ๊ฑฐ๋ ์ฐ๋ ์คํธ๋ฆผ
- InputStream ๊ณผ OutputStream์ด ์๋ค
๐น InputStream ํด๋์ค
- ์คํฌ๋ฆผ๊ฐ์ฒด๋ก 1byte์ฉ ์ฝ์ด์ค๋ ์คํธ๋ฆผ
โป ๋ฉ์๋
int read()
// 1. ํ ๋ฐ์ดํธ์ฉ ์ฝ์ด์ ๋ฐํ
// 2. ์คํธ๋ฆผ์ ๋์ ๋๋ฌํ๋ฉด -1 ๋ฐํ
int read(byte[] buf)
// 1. ์ง์ ๋ byte[] ๋ฐฐ์ด์ ํ ๋ฐ์ดํธ์ฉ ์ ์ฅ , ๋ฐํ๋๋ ๊ฐ์ ๋ฐฐ์ด์ ์ ์ฅ๋ ๋ฐ์ดํฐ ๊ฐฏ์
// 2. ์คํธ๋ฆผ์ ๋์ ๋๋ฌ์ -1 ๋ฐํ
void close()
// ์ ํ๋ฆฌ์ผ์ด์
์ด ์ฌ์ฉํ๋ ์์คํ
์ ์
์ถ๋ ฅ ์์์ ๋ฐํ
โป ํด๋์ค
InputStream
FileInputStream - ํ์ผ๊ณผ ์ฐ๊ฒฐํด์ ํ์ผ์ ๋ด์ฉ์ 1byte์ฉ ์ฝ์ด์ค๋ ์คํธ๋ฆผ
BufferedInputStream - ๋ค๋ฅธ ์คํธ๋ฆผ๊ณผ ์ฐ๊ฒฐํด์ ์ฝ๊ธฐ์ฑ๋ฅ์ ํฅ์์ํค๋ ์คํธ๋ฆผ
DataInputStream - ์คํธ๋ฆผ์ ์ฝ์ด์ ๊ฐ์๊ทธ๋๋ก ๋ณต์ํ๋ค
ObjectInputStream
OutputStream
FileOutputStream - ํ์ผ๊ณผ ์ฐ๊ฒฐํด์ ํ์ผ์ 1byte์ฉ ํ์ผ์ ๊ธฐ๋กํ๋ ์คํธ๋ฆผ
BufferedOutputStream - ๋ค๋ฅธ ์คํธ๋ฆผ๊ณผ ์ฐ๊ฒฐํด์ ์ฐ๊ธฐ ์ฑ๋ฅ์ ํฅ์์ํค๋ ์คํธ๋ฆผ
DataOutputStream - ๊ฐ์ ๋ฐ์ดํฐ ํ์
๊ทธ๋๋ก ์ถ๋ ฅํ๋ ์คํธ๋ฆผ
ObjectOutputStream
printStream - ์ฐ๊ธฐ ์ ์ฉ ์คํธ๋ฆผ , ํ์ค์ถ๋ ฅ / ํ์ค ์๋ฌ์ถ๋ ฅ ์คํธ๋ฆผ์ด๋ค
Reader
FileReader - ํ์ผ๊ณผ ์ฐ๊ฒฐํด์ ํ์ผ์ ๋ด์ฉ์ 1๊ธ์์ฉ ์ฝ์ด์ค๋ ์คํธ๋ฆผ
BufferedReader - ๋ค๋ฅธ ์คํธ๋ฆผ๊ณผ ์ฐ๊ฒฐํด์ ์ฝ๊ธฐ์ฑ๋์ ํฅ์์ํค๋ ์คํธ๋ฆผ
ํ
์คํธ๋ฅผ ํ ์ค์ฉ ์ฝ์ด์ค๋ ์คํธ๋ฆผ
ํ
์คํธ ์ฝ๊ธฐ์ ์ต์ ํ๋์ด์๋ ์คํธ๋ฆผ
InputStreamReader - InputStream๊ณผ ์ฐ๊ฒฐ ๊ฐ๋ฅํ Reader ๊ฐ์ฒด
Writer
FileWriter - ํ์ผ๊ณผ ์ฐ๊ฒฐํด์ 1๊ธ์์ฉ ํ์ผ์ ๊ธฐ๋กํ๋ ์คํธ๋ฆผ
BufferedWriter - ๋ค๋ฅธ ์คํธ๋ฆผ๊ณผ ์ฐ๊ฒฐํด์ ์ฐ๊ธฐ ์ฑ๋ฅ์ ํฅ์์ํค๋ ์คํธ๋ฆผ
OutputStreamWriter - OutputStream๊ฐ ์ฐ๊ฒฐํ๋
PrintWriter - ์ฐ๊ธฐ ์ ์ฉ ์คํธ๋ฆผ , ํ
์คํธ๊ธฐ๋ก์ ์ต์ ํ๋์ด ์๋ ์คํธ๋ฆผ
ํ์ค์ฉ ์ถ๋ ฅํ๋ println() ๋ฉ์๋๋ฅผ ์ ๊ณต
์๋ flush ๊ธฐ๋ฅ๋ ์ ๊ณตํ๋ค
๐น ํค๋ณด๋๋ก ์ ๋ ฅํ ๋ด์ฉ ํ์ค์ฉ ์ฝ์ด์ค๊ธฐ
class System {
static InputStream in; // ํ์ค ์
๋ ฅ ์คํธ๋ฆผ: 1byte์ฉ ์ฝ๋๋ค
static OutputStream out; // ํ์ค ์ถ๋ ฅ์คํธ๋ฆผ : println() ๋ฉ์๋๋ก ์ฌ๋ฌ์ข
๋ฅ์ ๋ฐ์ดํฐ๋ฅผ ์ถ๋ ฅ
static PrintStream err; // ํ์ค ์๋ฌ ์ถ๋ ฅ ์คํธ๋ฆผ : println() ๋ฉ์๋๋ก ์ฌ๋ฌ์ข
๋ฅ์ ๋ฐ์ดํฐ๋ฅผ ์ถ๋ ฅ
}
public static void main(String[] args) throws Exception {
// ํค๋ณด๋๋ก ์
๋ ฅ์ ํ์ค์ฉ ์
๋ ฅํ๊ธฐ
// Application -> BufferedReader -> InputStreamReader -> InputStream
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
System.out.println("### ์
๋ ฅ : ");
String text = reader.readLine();
System.out.println("์
๋ ฅ ๋ด์ฉ : " + text);
}
๐น InputStream ์ค์ต
// ํด๋น ํ์ผ์์ 1 byte '๋ง' ์ฝ๊ธฐ
// 1.์์ฑ์์ ํ์ผ๊ฒฝ๋ก๋ฅผ ๋ฌธ์์ด๋ก ์ ๋ฌ
// 2. ํด๋น ํ์ผ๊ณผ ์ฐ๊ฒฐ๊ดธ InputStream ์์ฑ๋จ
InputStream in = new FileInputStream("c:/files/sample.dat");
int oneByteData = in.read();
// read() a๋ฉ์๋๋ฅผ ํธ์ถ ํ๊ฒ๋๋ฉด ์คํธ๋ฆผ์ผ๋ก ๋ถํฐ 1๋ฐ์ดํธ๋ฅผ ์ฝ์ด์ด
// oneByteData์๋ read() ๋ฉ์๋๊ฐ ์คํธ๋ฆผ์ผ๋ก๋ถํฐ ์ฝ์ด์จ ๋ฐ์ดํฐ๊ฐ ์ ์ฅ๋๋ค.
1byte = ์์ด 1๊ธ์
Ex. ABC -> 3byte Wa -> 2byte
// ์คํธ๋ฆผ์ ๋๊น์ง ์ฝ์ด ํ์ผ๋ด์ฉ ๋ชจ๋ ์ฝ๊ธฐ
InputStream in = new FileInputStream(new File("c:/files", "sample.dat"));
// ์์ฑ์์ ํ์ผ๊ฒฝ๋ก ๋ฌธ์์ด๋ก ์
๋ ฅํ๊ณ ํ์ผ๊ณผ ์ฐ๊ฒฐ๋ inputStream ์์ฑ
int oneByteData = 0;
while ((oneByteData = in.read()) != -1) {
// oneByteData์๋ ํ ๋ฐ์ดํธ์ ์ฝ์ด์จ ๋ฐ์ดํฐ๊ฐ ๋ค์ด์๋ค
// ์ฝ์ด์จ ๋ฐ์ดํฐ ์ฒ๋ฆฌํ๊ธฐ
}
// int read() : 1byte์ฉ ์ฝ์ด์ ๋ฐํํ๋ค. ์คํธ๋ฆผ์ ๋์ ๋๋ฌํ๋ฉด -1์ ๋ฐํํ๋ค.
// while ๋ฐ๋ณต๋ฌธ์ผ๋ก -1์ด ์๋๋ผ๋ฉด ๊ณ์ ํด์ ๋ฐ๋ณต๋ฌธ ์คํ๋จ
// ์คํธ๋ฆผ์ ๋๊น์ง ๋๋ฌํ๋ฉด -1 ์ด ๋๋ฉด์ while ์กฐ๊ฑด ์ข
๋ฃ๋จ
// ์คํธ๋ฆผ์ ๋๊น์ง ์ฝ๊ธฐ
InputStream in = new FileInputStream(new File("c:/files/sample.dat"));
// bytes ๋ฐฐ์ด์ read(Byte[] buf) ๋ฉ์๋๊ฐ ์คํธ๋ฆผ์ผ๋ก๋ถํฐ ํ ๋ฒ์ ์ฝ์ด์ฌ byte๋ฐ์ดํฐ๋ฅผ
// ์ ์ฅํ๊ธฐ ์ํ ๋ฐฐ์ด.
byte[] bytes = new byte[1024];
// byte๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ 1024๋ผ๋ฉด len์ ๊ฐ์ 0 ~ 1014 ๋ฒ์์ ๊ฐ์ด๋ค.
int len = 0; // read(byte[] buf) ๋ฉ์๋๊ฐ ์คํธ๋ฆผ์ผ๋ก๋ถํฐ ํ๋ฒ์ ์ฝ์ด์ byate๋ฐฐ์ด์ ์ ์ฅํ ๋ฐ์ดํฐ์ ๊ฐฏ์๊ฐ ์ ์ฅ๋๋ค.
while ((len = in.read(bytes)) != -1) {
// bytes๋ฐฐ์ด์ ๋ฐ์ดํฐ ์ฒ๋ฆฌํ๊ธฐ
}
// read(Byte[] buf) ๋ฉ์๋๋ ํ๋ฒ์ฌ ์ฌ๋ฌ ๋ฐ์ดํธ๋ฅผ ์ฝ์
// ์ฝ์ ๋ฐ์ดํธ ์๋ฅผ ๋ฐํ ์คํธ๋ฆผ ๋์ ๋๋ฌ์ -1 ๋ฐํ
// ํ๋ฒ์ ๋ง์ ์์ ๋ฐ์ดํฐ ์ฝ์ ๋ ํจ์จ
// ์ด ์ฝ๋๋ inputSteam์ ๋ซ์์ผ ํ๋ค๊ณ ํจ in.close();
// ํ์ง ์์ผ๋ฉด ์์์ ๋์๊ฐ ๋ฐ์ํ๋ค๊ณ ํจ
๐นBufferInputStream ์ค์ต
// BufferedInputStream์ ๋ค๋ฅธ InputStream๊ณผ ์ฐ๊ฒฐํด์ ์ฌ์ฉํ๋ค.
BufferedInputStream in = new BufferedInputStream(new FileInputStream("c:/files/sample.dat"));
// 1. FileInputStra์ผ๋ก ํ์ผ๊ณผ ์ฐ๊ฒฐ๋ InputStream ์์ฑ
// 2. ๊ทธ๊ฑธ ๋ค์ BufferedInputStream ์์ฑ์ ์ ์ ๋ฌํด์ BufferedInputStrea ์์ฑ
// ์คํธ๋ฆผ์ ๋๊ฐ์ง ์ฝ๊ธฐ
int data = 0;
while ((data = in.read()) != -1) {
// data์ ๊ฐ ์ฒ๋ฆฌํ๊ธฐ
}
in.close();
// ๋๊ฐ์ read() ๋ฉ์๋ ๋ ์คํธ๋ฆผ ๋์๊ฐ๋ฉด -1 ๋ฐํํ๋๋ฐ
// -1 ์ ๊น์ง ๊ณ์ ๋ฐ๋ณต๋ฌธ ๋๋ ค์ ๋ฐ์ดํฐ ์ฝ์ด์ด
// in.close(); ํด์ ๋ฉ๋ชจ๋ฆฌ ๋์ ๋ง๊ธฐ
- BufferedInputStream์ InputStream์ ํ์ ํด๋์ค
- ๋ด๋ถ์ ์ผ๋ก ๋ฒํผ๋ฅผ ์ฌ์ฉํ์ฌ ์ ์ถ๋ ฅ์ ํจ์จ์ ํฅ์์ํจ๋ค
โ ์์๋ถํฐ ๊ทธ๋ฅ BufferedInputStream์ผ๋ก ํ๋ฉด์๋๋ ?
โถ BufferedInputStream์ ๋ด๋ถ์ ์ผ๋ก ๋ฒํผ๋ฅผ ๊ฐ์ง๊ณ ์์ด์ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ด์ฌ ๋ ๋ด๋ถ๋ฒํผ์
๋ฐ์ดํฐ๋ฅผ ๋จผ์ ์ฝ์ ํ ์ด ๋ฒํผ๋ก๋ถํฐ ๋ฐ์ดํฐ๋ฅผ ์ ๊ณตํ๋ค
์ด๋ ๊ฒ ํ๋ฉด ์ง์ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ด์ค๋ ๊ฒ ๋ณด๋ค ํจ์จ์ ์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌ ํ ์ ์๋ค๊ณ ํ๋ค..
/*
BufferedReader
` ๋ค๋ฅธ Reader์ ์ฐ๊ฒฐํด์ ์ฝ๊ธฐ ์ฑ๋ฅ์ ํฅ์์ํค๋ ์คํธ๋ฆผ
` ์คํธ๋ฆผ์ ๋์๋ง๋๋ฉด null ๋ฐํ
` ํ
์คํธ๋ฅผ ์ฝ์ด์ฌ ๋ ์ค ๋ฐ๊ฟ ๋ฌธ์๋ก ๋ฐ๋ก ์๊น์ง ์ฝ์ด์จ๋ค
*/
public static void main(String[] args) throws Exception {
String path = "C:/Users/Han/IdeaProjects/HTA/Java/io/io3/data.csv";
BufferedReader reader = new BufferedReader(new FileReader(path));
// BufferedReader์ readLine() ๋ฉ์๋๋ก ์ฝ์ด์จ ํ
์คํธ๋ฅผ ๋์
ํ ๋ณ์
String text = null;
// (text = reader.readLin() ) != null )์
// reader.readLine() ์ฝ์ด์จ ํ
์คํธ๋ฅผ text ๋ณ์์ ๋์
// text ๋ณ์์ ๋์
๋ ๋ฌธ์์ด์ด null ์ด ์๋๋ผ๋ฉด while๋ฌธ์ ๋ธ๋ญ๋ด์ ์ํ๋ฌธ์ ์ํ
while ((text = reader.readLine()) != null) {
// ์ฝ์ด์จ ๋ฌธ์์ด์ ๋ถ์ํด์ ํ๊ท ์ ์๋ฅผ ๊ณ์ฐํ๊ณ ์ถ๋ ฅํ๋ ์ํ๋ฌธ
// text์ ๋์
๋ ๋ฌธ์์ด์ "๊น์ ์ ,100,89,79"๊ณผ ๊ฐ์ํํ
// ","๋ฅผ ๊ตฌ๋ถ์๋ก ๋ฌธ์์ด์ ์๋ผ์ ๋ฐฐ์ด๋ก ๋ฐํ
String[] items = text.split(",");
// ๋ฐฐ์ด์ ์ ์ฅ๋ ๊ฐ์ ์กฐํํ๊ณ , ํ์ํ ๊ฒฝ์ฐ ๊ฐ์ ๋ณํํ๋ค.
String name = items[0];
int kor = Integer.parseInt(items[1]);
int eng = Integer.parseInt(items[2]);
int math = Integer.parseInt(items[3]);
int total = kor + eng + math;
int average = total / 3;
System.out.println("์ด๋ฆ : " + name);
System.out.println("ํ๊ท : " + average);
System.out.println();
// System.out.println(text);
}
reader.close();
}
'Language > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Java enum (1) | 2023.12.01 |
---|---|
Java ํ๋ก์ธ์ค์ ์ค๋ ๋ (1) | 2023.11.29 |
Java Exception (4) | 2023.11.22 |
Java ์ ๋ค๋ฆญ, ์ปฌ๋ ์ , Set , List , Map , Stack (1) | 2023.11.20 |
Java Iterator , Score CRUD (1) | 2023.11.17 |