// read()의 내부 구조 — 추상 메서드를 활용한 템플릿 메서드 패턴
public abstract class InputStream {
    abstract int read();  // 자손 클래스가 구현

    int read(byte[] b, int off, int len) {
        for (int i = off; i < off + len; i++) {
            b[i] = (byte) read();  // 추상 메서드 호출
        }
    }

    int read(byte[] b) {
        return read(b, 0, b.length);  // 위 메서드 재활용
    }
}

// 파일 읽기
try (FileInputStream fis = new FileInputStream("input.txt")) {
    int data;
    while ((data = fis.read()) != -1) {
        System.out.print((char) data);
    }
} catch (IOException e) {
    e.printStackTrace();
}

// 파일 복사
try (FileInputStream fis = new FileInputStream("source.txt");
     FileOutputStream fos = new FileOutputStream("copy.txt")) {

    int data;
    while ((data = fis.read()) != -1) {
        fos.write(data);
    }
} catch (IOException e) {
    e.printStackTrace();
}

// 파일에 이어쓰기
try (FileOutputStream fos = new FileOutputStream("log.txt", true)) {
    String msg = "새로운 로그 추가\n";
    fos.write(msg.getBytes());
}

byte[] inSrc = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
byte[] outSrc = null;

ByteArrayInputStream input = new ByteArrayInputStream(inSrc);
ByteArrayOutputStream output = new ByteArrayOutputStream();

int data;
while ((data = input.read()) != -1) {
    output.write(data);
}

outSrc = output.toByteArray();
System.out.println(Arrays.toString(outSrc));
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

// 기반 스트림 생성
FileInputStream fis = new FileInputStream("file.txt");
// 보조 스트림으로 감싸기
BufferedInputStream bis = new BufferedInputStream(fis);
// 보조 스트림을 통해 읽기
bis.read();

// 버퍼 있는 스트림 vs 없는 스트림 — 성능 차이
// 버퍼 없이 파일 복사 (느림)
try (FileInputStream fis = new FileInputStream("large.dat");
     FileOutputStream fos = new FileOutputStream("copy.dat")) {
    int b;
    while ((b = fis.read()) != -1) fos.write(b);
}

// 버퍼로 감싸서 파일 복사 (빠름)
try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("large.dat"));
     BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.dat"))) {
    int b;
    while ((b = bis.read()) != -1) bos.write(b);
}

// 기본 자료형 단위로 파일에 쓰기
try (DataOutputStream dos = new DataOutputStream(
        new FileOutputStream("data.bin"))) {
    dos.writeInt(100);
    dos.writeFloat(3.14f);
    dos.writeBoolean(true);
    dos.writeUTF("Hello");
}

// 기본 자료형 단위로 파일에서 읽기 (쓴 순서대로 읽어야 함)
try (DataInputStream dis = new DataInputStream(
        new FileInputStream("data.bin"))) {
    int i = dis.readInt();         // 100
    float f = dis.readFloat();     // 3.14
    boolean b = dis.readBoolean(); // true
    String s = dis.readUTF();      // "Hello"
}

int age = 25;
String name = "홍길동";
double score = 95.7;

System.out.printf("이름: %s, 나이: %d, 점수: %.1f%n", name, age, score);
// 이름: 홍길동, 나이: 25, 점수: 95.7

// 텍스트 파일 읽기
try (FileReader fr = new FileReader("input.txt")) {
    int ch;
    while ((ch = fr.read()) != -1) {
        System.out.print((char) ch);
    }
}

// 텍스트 파일 쓰기
try (FileWriter fw = new FileWriter("output.txt")) {
    fw.write("안녕하세요\n");
    fw.write("Java I/O 학습 중입니다.");
}

StringWriter sw = new StringWriter();
sw.write("Hello ");
sw.write("World");

String result = sw.toString();          // "Hello World"
StringBuffer buf = sw.getBuffer();      // StringBuffer 직접 접근

// 파일을 라인 단위로 읽기
try (BufferedReader br = new BufferedReader(new FileReader("input.txt"))) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
}

// 라인 단위로 쓰기
try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
    bw.write("첫 번째 줄");
    bw.newLine();  // 줄바꿈
    bw.write("두 번째 줄");
}

// System.in(바이트 스트림)을 문자 스트림으로 변환하여 라인 단위 입력
BufferedReader br = new BufferedReader(
    new InputStreamReader(System.in));
String input = br.readLine();

// 인코딩을 지정하여 파일 읽기
InputStreamReader isr = new InputStreamReader(
    new FileInputStream("data.txt"), "UTF-8");

// 현재 인코딩 확인
System.out.println(isr.getEncoding());  // UTF-8

// 표준 출력을 파일로 변경
PrintStream ps = new PrintStream(new FileOutputStream("output.log"));
System.setOut(ps);

System.out.println("이 내용은 파일에 출력됩니다");

try (RandomAccessFile raf = new RandomAccessFile("data.dat", "rw")) {
    // 쓰기
    raf.writeInt(100);
    raf.writeUTF("Hello");

    // 파일 포인터 확인
    System.out.println("현재 위치: " + raf.getFilePointer());

    // 파일 포인터를 처음으로 이동
    raf.seek(0);

    // 읽기
    int num = raf.readInt();
    String str = raf.readUTF();
}

// File 인스턴스 생성 (파일이 생성되지는 않음)
File f = new File("C:\\data\\test.txt");

// 새 파일 실제 생성
f.createNewFile();

// 디렉터리 생성
File dir = new File("C:\\data\\newDir");
dir.mkdir();       // 단일 디렉터리 생성
dir.mkdirs();      // 중간 경로까지 모두 생성

File f = new File("./src/../data/test.txt");

System.out.println(f.getPath());            // .\src\..\data\test.txt
System.out.println(f.getAbsolutePath());    // C:\project\.\src\..\data\test.txt
System.out.println(f.getCanonicalPath());   // C:\project\data\test.txt

File f = new File("test.txt");

// 파일 정보
f.exists();        // 존재 여부
f.isFile();        // 파일인지
f.isDirectory();   // 디렉터리인지
f.canRead();       // 읽기 가능 여부
f.canWrite();      // 쓰기 가능 여부
f.length();        // 파일 크기 (byte)
f.lastModified();  // 마지막 수정 시간

// 디렉터리 내 파일 목록
File dir = new File("C:\\data");
String[] fileList = dir.list();       // 파일명 배열
File[] files = dir.listFiles();       // File 객체 배열

// 직렬화 — 객체를 파일에 저장
try (ObjectOutputStream oos = new ObjectOutputStream(
        new FileOutputStream("user.ser"))) {
    oos.writeObject(new UserInfo("홍길동", 25));
}

// 역직렬화 — 파일에서 객체를 읽기
try (ObjectInputStream ois = new ObjectInputStream(
        new FileInputStream("user.ser"))) {
    UserInfo info = (UserInfo) ois.readObject();
    System.out.println(info.getName());  // "홍길동"
}

public class UserInfo implements Serializable {
    private String name;
    private int age;
    private transient String password;  // 직렬화 제외

    public UserInfo(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // getter/setter...
}

// 상속과 직렬화
class Parent {  // Serializable 미구현
    int parentValue = 100;
}

class Child extends Parent implements Serializable {
    int childValue = 200;
}

// Child를 직렬화하면 childValue(200)만 저장된다
// parentValue(100)는 직렬화되지 않는다

// 클래스 내에 serialVersionUID를 직접 정의하여 버전 관리
class MyData implements Serializable {
    static final long serialVersionUID = 1L;

    int value;
    String name;
    // 필드가 추가되어도 serialVersionUID가 같으면 역직렬화 가능
}