Java IO流实战之文件复制、文本读写、对象序列化详细解析

public class FileCopyBasic {
    public static void main(String[] args) {
        // 源文件和目标文件路径
        String sourcePath = "source.jpg";
        String targetPath = "target_basic.jpg";
        
        // 声明流对象（try-with-resources语法自动关闭资源）
        try (FileInputStream fis = new FileInputStream(sourcePath);
             FileOutputStream fos = new FileOutputStream(targetPath)) {
            
            byte[] buffer = new byte[1024]; // 缓冲区（一次读1024字节）
            int len; // 实际读取的字节数
            
            // 循环读取：当len=-1时表示读取完毕
            while ((len = fis.read(buffer)) != -1) {
                // 写入缓冲区中的有效数据（避免写入空字节）
                fos.write(buffer, 0, len);
            }
            System.out.println("基础字节流复制完成！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class FileCopyWithBuffer {
    public static void main(String[] args) {
        String sourcePath = "source.jpg";
        String targetPath = "target_buffer.jpg";
        
        // 缓冲流包装基础字节流
        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);
                // 缓冲流会自动刷新，大文件可手动调用bos.flush()避免数据滞留
            }
            System.out.println("缓冲流复制完成！");
        } 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()) {
            
            // 传输数据：从输入通道到输出通道，每次最多传输Integer.MAX_VALUE字节
            long position = 0;
            long size = inChannel.size();
            while (position < size) {
                position += inChannel.transferTo(position, Integer.MAX_VALUE, outChannel);
            }
            System.out.println("NIO通道复制完成！");
        } 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]; // 字符缓冲区
            int len;
            while ((len = fr.read(buffer)) != -1) {
                fw.write(buffer, 0, len);
            }
            System.out.println("基础字符流读写完成！");
        } 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"; // 明确指定编码
        
        // 字节流→字符流（指定编码）
        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; // 存储每行内容
            // 逐行读取（readLine()不包含换行符）
            while ((line = br.readLine()) != null) {
                bw.write(line); // 写入一行内容
                bw.newLine(); // 换行（自动适配系统换行符：\n或\r\n）
            }
            System.out.println("缓冲字符流逐行读写完成！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

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

// 实现Serializable接口（标记接口，无方法）
public class User implements Serializable {
    // 序列化版本号（强烈建议显式声明，避免类结构变化导致反序列化失败）
    private static final long serialVersionUID = 1L;
    
    private String username;
    private int age;
    private transient String password; // transient修饰的字段不参与序列化
    private Date registerTime;
    
    // 构造器、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. 反序列化：从文件恢复对象
        try (ObjectInputStream ois = new ObjectInputStream(
                 new FileInputStream(filePath))) {
            User deserializedUser = (User) ois.readObject();
            System.out.println("反序列化结果：" + deserializedUser);
            // 注意：password为null（transient字段未被序列化）
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

序列化完成：User{username='zhangsan', age=25, password='123456', registerTime=...}
反序列化结果：User{username='zhangsan', age=25, password='null', registerTime=...}