public class FileCopyBasic {
    public static void main(String[] args) {
        // 源文件和目標(biāo)文件路徑
        String sourcePath = "source.jpg";
        String targetPath = "target_basic.jpg";
        
        // 聲明流對象（try-with-resources語法自動關(guān)閉資源）
        try (FileInputStream fis = new FileInputStream(sourcePath);
             FileOutputStream fos = new FileOutputStream(targetPath)) {
            
            byte[] buffer = new byte[1024]; // 緩沖區(qū)（一次讀1024字節(jié)）
            int len; // 實(shí)際讀取的字節(jié)數(shù)
            
            // 循環(huán)讀取：當(dāng)len=-1時表示讀取完畢
            while ((len = fis.read(buffer)) != -1) {
                // 寫入緩沖區(qū)中的有效數(shù)據(jù)（避免寫入空字節(jié)）
                fos.write(buffer, 0, len);
            }
            System.out.println("基礎(chǔ)字節(jié)流復(fù)制完成！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class FileCopyWithBuffer {
    public static void main(String[] args) {
        String sourcePath = "source.jpg";
        String targetPath = "target_buffer.jpg";
        
        // 緩沖流包裝基礎(chǔ)字節(jié)流
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(sourcePath));
             BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(targetPath))) {
            
            byte[] buffer = new byte[1024];
            int len;
            while ((len = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, len);
                // 緩沖流會自動刷新，大文件可手動調(diào)用bos.flush()避免數(shù)據(jù)滯留
            }
            System.out.println("緩沖流復(fù)制完成！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class FileCopyWithChannel {
    public static void main(String[] args) {
        String sourcePath = "source.mp4";
        String targetPath = "target_channel.mp4";
        
        try (FileChannel inChannel = new FileInputStream(sourcePath).getChannel();
             FileChannel outChannel = new FileOutputStream(targetPath).getChannel()) {
            
            // 傳輸數(shù)據(jù)：從輸入通道到輸出通道，每次最多傳輸Integer.MAX_VALUE字節(jié)
            long position = 0;
            long size = inChannel.size();
            while (position < size) {
                position += inChannel.transferTo(position, Integer.MAX_VALUE, outChannel);
            }
            System.out.println("NIO通道復(fù)制完成！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class TextReadWriteBasic {
    public static void main(String[] args) {
        String sourceTxt = "source.txt";
        String targetTxt = "target_basic.txt";
        
        // 字符流讀寫文本
        try (FileReader fr = new FileReader(sourceTxt);
             FileWriter fw = new FileWriter(targetTxt)) {
            
            char[] buffer = new char[1024]; // 字符緩沖區(qū)
            int len;
            while ((len = fr.read(buffer)) != -1) {
                fw.write(buffer, 0, len);
            }
            System.out.println("基礎(chǔ)字符流讀寫完成！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class TextReadWriteWithCharset {
    public static void main(String[] args) {
        String sourceTxt = "source_utf8.txt";
        String targetTxt = "target_utf8.txt";
        String charset = "UTF-8"; // 明確指定編碼
        
        // 字節(jié)流→字符流（指定編碼）
        try (InputStreamReader isr = new InputStreamReader(
                 new FileInputStream(sourceTxt), charset);
             OutputStreamWriter osw = new OutputStreamWriter(
                 new FileOutputStream(targetTxt), charset)) {
            
            char[] buffer = new char[1024];
            int len;
            while ((len = isr.read(buffer)) != -1) {
                osw.write(buffer, 0, len);
            }
            System.out.println("指定編碼的字符流讀寫完成！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class TextReadWriteWithBuffer {
    public static void main(String[] args) {
        String sourceTxt = "article.txt";
        String targetTxt = "article_copy.txt";
        
        try (BufferedReader br = new BufferedReader(
                 new InputStreamReader(new FileInputStream(sourceTxt), "UTF-8"));
             BufferedWriter bw = new BufferedWriter(
                 new OutputStreamWriter(new FileOutputStream(targetTxt), "UTF-8"))) {
            
            String line; // 存儲每行內(nèi)容
            // 逐行讀取（readLine()不包含換行符）
            while ((line = br.readLine()) != null) {
                bw.write(line); // 寫入一行內(nèi)容
                bw.newLine(); // 換行（自動適配系統(tǒng)換行符：\n或\r\n）
            }
            System.out.println("緩沖字符流逐行讀寫完成！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.Serializable;
import java.util.Date;

// 實(shí)現(xiàn)Serializable接口（標(biāo)記接口，無方法）
public class User implements Serializable {
    // 序列化版本號（強(qiáng)烈建議顯式聲明，避免類結(jié)構(gòu)變化導(dǎo)致反序列化失?。?
    private static final long serialVersionUID = 1L;
    
    private String username;
    private int age;
    private transient String password; // transient修飾的字段不參與序列化
    private Date registerTime;
    
    // 構(gòu)造器、getter、setter、toString()
    public User(String username, int age, String password) {
        this.username = username;
        this.age = age;
        this.password = password;
        this.registerTime = new Date();
    }
    
    @Override
    public String toString() {
        return "User{username='" + username + "', age=" + age + 
               ", password='" + password + "', registerTime=" + registerTime + "}";
    }
}

import java.io.*;

public class ObjectSerialization {
    public static void main(String[] args) {
        String filePath = "user.ser";
        User user = new User("zhangsan", 25, "123456");
        
        // 1. 序列化：將對象寫入文件
        try (ObjectOutputStream oos = new ObjectOutputStream(
                 new FileOutputStream(filePath))) {
            oos.writeObject(user);
            System.out.println("序列化完成：" + user);
        } catch (IOException e) {
            e.printStackTrace();
        }
        
        // 2. 反序列化：從文件恢復(fù)對象
        try (ObjectInputStream ois = new ObjectInputStream(
                 new FileInputStream(filePath))) {
            User deserializedUser = (User) ois.readObject();
            System.out.println("反序列化結(jié)果：" + deserializedUser);
            // 注意：password為null（transient字段未被序列化）
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

序列化完成：User{username='zhangsan', age=25, password='123456', registerTime=...}
反序列化結(jié)果：User{username='zhangsan', age=25, password='null', registerTime=...}