학원 #43일차: 파일 입출력 API

FileOutputStream out = new FileOutputStream("temp/test1.data");
out.write(0x7a6b5c4d); // 출력하는 값은 0x4d
out.close();

FileInputStream in = new FileInputStream("temp/test1.data");
int b = in.read(); // 0x4d
in.close();

FileOutputStream out = new FileOutputStream("temp/test.data");
byte[] bytes = new byte[] {0x7a, 0x6b, 0x5c, 0x4d, 0x3e, 0x2f, 0x30};
out.write(bytes);
out.close();

out.write(bytes, 2, 3); // 2번 데이터부터 3바이트를 출력한다.

FileInputStream in = new FileInputStream("temp/test1.data");
// 바이트를 저장할 배열을 넉넉히 준비
byte[] buf = new byte[100];
int count = in.read(buf);
in.close();

System.out.println("읽은 바이트 수: %d\n", count);
for (int i = 0; i < count; i++)
  System.out.printf("%x ", buf[i]);

/*
읽은 바이트 수: 7
7a 6b 5c 4d 3e 2f 30 
*/

int count = in.read(buf, 10, 40); // 40바이트를 읽어 10번 방부터 저장한다.
in.close();
System.out.printf("%d\n", count);
for (int i = 0; i < 20; i++)
  System.out.printf("%x ", buf[i]);
//7
//0 0 0 0 0 0 0 0 0 0 7a 6b 5c 4d 3e 2f 30 0 0 0 

//1) 파일 정보를 준비한다.
File file = new File("sample/photo1.jpg");

//2) 파일을 읽을 도구를 준비한다.
FileInputStream in = new FileInputStream(file);

// => SOI(Start of Image) Segment 읽기: 2바이트
int b1 = in.read(); // 00 00 00 ff
int b2 = in.read(); // 00 00 00 d8
int soi = b1 << 8 | b2;
//   00 00 00 ff <== b1
//   00 00 ff 00 <== b1 << 8
// | 00 00 00 d8 <== b2
// ------------------
//   00 00 ff d8
System.out.printf("SOI: %x\n", soi);

// => JFIF-APP0 Segment Marker 읽기: 2바이트
int jfifApp0Marker = in.read() << 8 | in.read();
System.out.printf("JFIF APP0 Marker: %x\n", jfifApp0Marker);

// => JFIF-APP0 Length: 2바이트
int jfifApp0Length = in.read() << 8 | in.read();
System.out.printf("JFIF APP0 정보 길이: %d\n", jfifApp0Length);

byte[] jfifApp0Info = new byte[jfifApp0Length];
in.read(jfifApp0Info);

// => JFIF-APP0 Length: 5바이트
String jfifApp0Id = new String(jfiApp0Info, 0, 4);
System.out.printf("JFIF App ID: %s\n", jfifApp0Id);

// SOF0(Start of Frame) 정보 읽기
// - 그림 이미지의 크기 및 샘플링에 관한 정보를 보관하고 있다.
// - 0xFFC0 ~ 0xFFC2 로 표시한다.


// => SOF Marker 찾기
int b;
while (true) {
  b = in.read();
  if (b == -1)
    break;
  if (b == 0xFF) {
    b = in.read();
    if (b == -1)
      break;
    if (b >= 0xC0 && b <= 0xC2)
      break;
  }
}

if (b == -1) {
  System.out.prinln("유효한 JPEG 파일이 아닙니다.");
  return;
}

// => SOF Length 읽기: 2바이트
int sofLength = in.read() << 9 | in.read();
System.out.printf("%SOF 데이터 크기: %d\n", sofLength);

// => SOF 데이터 읽기: 17바이트 (위에서 알아낸 크기)
byte[] sofData = new byte[sofLength];
in.read(sofData);

// => SOF 샘플링 정밀도: 1바이트
System.out.printf("SOF 샘플링 정밀도: %s\n", sofData[0]);

// => SOF 이미지 높이: 2바이트
int height = ((sofData[1] << 8) & 0xff00) | (sofData[2] & 0xff);

// => SOF 이미지 너비: 2바이트
int width = ((softData[3] << 8) & 0xff00) || (softData[4] & 0xff));
System.out.printf("SOF 이미지 크기(w x h): %d x %d\n", width, height);

in.close();

String str = new String("AB가각");
System.out.printf("file.encoding=%s\n", System.getProperty("file.encoding"));

// 1. 인코딩 지정X 
byte[] bytes1 = str.getBytes();
// 이클립스: UCS2 => UTF-8
// Windows: UCS2 => MS949
// Linux: UCS2 => UTF-8
// macOS: UCS2 => UTF-8
for (byte b : bytes1) System.out.printf("%x ", b);
// (이클립스) 41 42 ea b0 80 ea b0 81
FileOutputStream out1 = new FileOutputStream("temp/utf.txt");
out1.write(bytes);

// 2. MS949로 인코딩하기
byte[] bytes2 = str.getBytes("MS949");; // UCS2 ==> MS949
for (byte b : bytes2) System.out.printf("%x ", b)
// 41 42 b0 a1 b0 a2
FileOutputStream out2 = new FileOutputStream("temp/ms949.txt");
out2.write(bytes2);

// 3. UTF-16BE로 인코딩하기
byte[] bytes3 = str.getBytes("UTF-16BE"); // UCS2 ==> UTF-16BE
for (byte b : bytes3) System.out.printf("%x ", b);
// 0 41 0 42 ac 0 ac 1
FileOutputStream out3 = new FileOutputStream("temp/utf16be.txt");
out3.write(bytes3);

// 4. UTF-16LE로 인코딩하기
byte[] bytes4 = str.getBytes("UTF-16LE"); // UCS2 ==> UTF-16LE
for (byte b : bytes4) System.out.printf("%x ", b);
// 41 0 42 0 0 ac 1 ac
FileOutputStream out4 = new FileOutputStream("temp/utf16le.txt");
out4.write(bytes4);

// 5. UTF-8로 인코딩하기
byte[] bytes5 = str.getBytes("UTF-8"); // UCS2 ==> UTF-8
for (byte b : bytes5) System.out.printf("%x ", b);
// 41 42 ea b0 80 ea b0 81 
FileOutputStream out5 = new FileOutputStream("temp/utf8.txt");
out4.write(bytes5);

StringBuffer  strbuf = new StringBuffer();
FileInputStream in = new FileInputStream("sample/ms949");

// 'A' 문자 읽기
int b = in.read(); // 1 byte 읽기

// 'B' 문자 읽기
b = in.read();

// '가' 문자 읽기
b = in.read() << 8 | in.read(); // 2byte 읽기

// '각' 문자 읽기
b = in.read() << 8 | in.read(); // 2byte 읽기

// JVM 환경변수 file.encoding 값
System.out.printf("file.encoding=%s\n", System.getProperty("file.encoding"));
FileInputStream in = new FileInputStream("sample/utf8.txt");

// 파일의 데이터를 한 번에 읽어오자.
byte[] buf = new byte[1000];
int count = in.read(buf);// <= 41 42 ea b0 80 ea b0 81 (AB가각)

in.close();

// 읽은 바이트를 String 객체로 만들어보자.
String str = new String(buf, 0, count); //=> 바이트가 어떤 문자 집합으로 되었는지 알려주지 않는다면?
System.out.println(str);

// JVM 환경변수 file.encoding 값
System.out.printf("file.encoding=%s\n", System.getProperty("file.encoding"));
FileInputStream in = new FileInputStream("sample/ms949.txt");

// 파일의 데이터를 한 번에 읽어오자.
byte[] buf = new byte[1000];
int count = in.read(buf);

in.close();

// 읽은 바이트를 String 객체로 만들어보자.
String str = new String(buf, 0, count); //=> 바이트가 어떤 문자 집합으로 되었는지 알려주지 않는다면?
System.out.println(str);

// MS949 코드를 UTF-8 문자로 가정하고 다룰 때 한글이 깨지는 원리! 
// - ms949.txt 
//   => 01000001 01000010 10110000 10100001 10110000 10100010 = 41 42 b0 a1 b0 a2
// - MS949 코드를 변환할 때 UTF-8 문자표를 사용하면 다음과 같이 잘못된 변환을 수행한다.
//   byte(UTF-8) => char(UCS2) 
//     01000001  -> 00000000 01000001 (00 41) = 'A' <-- 정상적으로 변환되었음.
//     01000010  -> 00000000 01000010 (00 42) = 'B' <-- 정상적으로 변환되었음.
//     10110000  -> 꽝 (xx xx) <-- 해당 바이트가 UTF-8 코드 값이 아니기 때문에 UCS2로 변환할 수 없다.
//     10100001  -> 꽝 (xx xx) <-- 그래서 꽝을 의미하는 특정 코드 값이 들어 갈 것이다.
//     10110000  -> 꽝 (xx xx) <-- 그 코드 값을  문자로 출력하면 => �
//     10100010  -> 꽝 (xx xx)

System.out.printf("file.encoding=%s\n", System.getProperty("file.encoding")); // UTF-8
FileInputStream in = new FileInputStream("sample/utf16le.txt");

byte[] buf = new byte[100];
int count = in.read(buf);

in.close();

String str = new String(buf, 0, count, "UTF-16LE");
System.out.println(str);

// character stream - 문자 단위로 출력하기
package com.eomcs.io.ex03;

import java.io.FileWriter;

public class Exam0110 {
  public static void main(String[] args) throws Exception {
    // 1) 문자 단위로 출력할 도구 준비
    FileWriter out = new FileWriter("temp/test2.txt");

    // 현재 JVM 환경 변수 'file.encoding' 값 알아내기
    System.out.printf("file.encoding=%s\n", System.getProperty("file.encoding"));

    // => 이 예제를 이클립스에서 실행한다면,
    // 앞의 2바이트는 버리고,
    // 뒤의 2바이트(UCS2)를 UTF-8 코드표에 따라
    // 1 ~ 4 바이트 값으로 변환하여 파일에 쓴다.
    // => 즉 이클립스에서 자바 프로그램을 실행할 때
    //    -Dfile.encoding=UTF-8 옵션을 붙여 실행하기 때문이다.
    // => OS의 기본 문자표로 출력하고 싶다면,
    //    콘솔창에서 위 옵션 없이 직접 이 클래스를 실행하라.
    // 
    // UCS2에서 한글 '가'는 ac00이다.
    out.write(0x7a6bac00); 
    // - 앞의 2바이트(7a6b)는 버린다.
    // - 뒤의 2바이트(ac00)은 UTF-8(eab080) 코드 값으로 변환되어 파일에 출력된다.

    // UCS2에서 영어 A는 0041이다.
    // 출력하면, UTF-8 코드 값(41)이 파일에 출력된다.
    out.write(0x7a5f0041);  // 
    // - 앞의 2바이트(7a5f)는 버린다.
    // - 뒤의 2바이트는 UTF-8(41) 코드 값으로 변환되어 파일에 출력된다.

    out.close();

    System.out.println("출력 완료!");

  }
}

// 1) 파일의 데이터를 읽을 객체를 준비한다. 
FileReader in = new FileReader("sample/ms949.txt"); // 41 42 b0 a1 b0 a2

// 2) 출력 스트림 객체를 생성할 때 파일의 문자 집합을 지정하지 않으면,
//    JVM 환경 변수 'file.encoding'에 설정된 문자코드표에 따라 
//    바이트를 읽어서 UCS2로 바꾼 후에 리턴한다.

// 현재 JVM 환경 변수 'file.encoding' 값 알아내기
System.out.printf("file.encoding=%s\n", System.getProperty("file.encoding"));

// file.encoding이 UTF-8로 되어 있다면,
// => 영어는 1바이를 읽어서 2바이트 UCS2로 변환한다.
// => MS949도 영어인 경우 UTF-8과 같기 때문에 변환하는데 문제가 없다.
int ch1 = in.read(); // 41 => 0041('A')
int ch2 = in.read(); // 42 => 0042('B')

// => 한글은 MS949와 UTF-8이 다르다.
//    MS949로 인코딩 된 것을 UTF-8로 간주하여 변환한다면,
//    UTF-8 문자가 아니기 때문에 
//    다음과 같이 잘못되었다는 의미로 특정 값(fffd)으로 변환한다.
int ch3 = in.read(); // b0 a1 => fffd => �
int ch4 = in.read(); // b0 a2 => fffd => �

// 3) 읽기 도구를 닫는다.
in.close();

System.out.printf("%x, %x, %x, %x\n", ch1, ch2, ch3, ch4);

FileWriter out = new FileWriter("temp/test2.txt");

char[] chars = new char[] {'A', 'B', 'C', '가', '각', '간', '똘', '똥'};

out.write(chars); // 문자 배열 전체를 출력한다.

// 당연히 UCS2를 JVM 환경 변수 'file.encoding'에 설정된 문자 코드표에 따라 변환하여 출력한다.
// JVM이 입출력 문자 코드표로 UTF-8을 사용한다면
// 영어는 1바이트로 변환되어 출력될 것이고,
// 한글은 3바이트로 변환되어 출력될 것이다.
// JVM(UCS2)    File(UTF-8)
// 00 41    ==> 41
// 00 42    ==> 42
// 00 43    ==> 43
// ac 00    ==> ea b0 80
// ac 01    ==> ea b0 81
// ac 04    ==> ea b0 84
// b6 18    ==> eb 98 98
// b6 25    ==> eb 98 a5
out.close();

FileWriter out = new FileWriter("temp/test2.txt");
char[] chars = new char[] {'A','B','C','가','각','간','똘','똥'}; 
out.write(chars, 2, 3); // 2번 문자부터 3 개의 문자를 출력한다.
out.close();
System.out.println("데이터 출력 완료!");

FileReader in = new FileReader("temp/test2.txt");

char[] buf = new char[100];

// read(버퍼의주소)
// => 버퍼가 꽉 찰 때까지 읽는다.
// => 물론 버퍼 크기보다 파일의 데이터가 적으면 파일을 모두 읽어 버퍼에 저장한다.
// => 리턴 값은 읽은 문자의 개수이다. 바이트의 개수가 아니다!!!!!
//    FileInputStream.read()의 리턴 값은 읽은 바이트의 개수였다.
// => 파일을 읽을 때 JVM 환경 변수 'file.encoding'에 설정된 문자코드표에 따라 바이트를 읽는다.
//    그리고 2바이트 UCS2 코드 값으로 변환하여 리턴한다.
// => JVM의 문자코드표가 UTF-8이라면,
//    파일을 읽을 때, 영어나 숫자, 특수기호는 1바이트를 읽어 UCS2으로 변환할 것이고
//    한글은 3바이트를 읽어 UCS2으로 변환할 것이다.
int count = in.read(buf); 

// File(UTF-8)  JVM(UCS2)    
// 41       ==> 00 41
// 42       ==> 00 42
// 43       ==> 00 43
// ea b0 80 ==> ac 00
// ea b0 81 ==> ac 01
// ea b0 84 ==> ac 04
// eb 98 98 ==> b6 18
// eb 98 a5 ==> b6 25

in.close();

System.out.printf("%d\n", count);
for (int i = 0; i < count; i++)
  System.out.printf("%c(%x)\n", buf[i], (int)buf[i]);

System.out.println();

FileReader in = new FileReader("temp/test2.txt");

char[] buf = new char[100];

// read(버퍼의주소, 저장할위치, 읽을바이트개수)
// => 리턴 값은 실제 읽은 문자의 개수이다.
int count = in.read(buf, 10, 40); // 40개의 문자를 읽어 10번 방부터 저장한다.

in.close();

System.out.printf("%d\n", count);

for (int i = 0; i < 20; i++)
  System.out.printf("%c(%x) ", buf[i], (int) buf[i]);

System.out.println();