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=...}