io流文件拷贝及序列化对象和反序列化

1.文件拷贝

方式一:字节缓冲流文件拷贝(一般用于拷贝图片，视频， 音频等二进制文件， 文本也可以拷贝但是一般用字符流)

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class Test06Buffered {
    public static void main(String[] args) {
        String sourcePath =  "d:/Test.jpg";  //源文件路径 要已经存在 否则会报错
        String targetPath = "d:/Test01.jpg"; //目标文件路径 不需要已经存在 启动程序会自动创建
        copyFile(sourcePath, targetPath);
    }
    public static void  copyFile(String sourcePath, String targetPath){
        FileInputStream fis = null;          // 字节输入流
        FileOutputStream fos = null;        // 字节输出流
        BufferedInputStream bis = null;     //包装流
        BufferedOutputStream bos = null;    //包装流
        try{
            fis = new FileInputStream(sourcePath);
            bis = new BufferedInputStream(fis);
            fos = new FileOutputStream(targetPath);
            bos = new BufferedOutputStream(fos);
            byte[] buff = new byte[1024];
            int temp = 0;
            while((temp = bis.read(buff))!= -1){//从输入缓冲流去读取文件数据
                bos.write(buff, 0, temp);  // 将输出缓冲流中数据写入文件中
            }
            bos.flush(); //将数据从内存中写入到磁盘中
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                //注意：关闭流顺序："后开的先关闭"
                if(bos != null){
                    bos.close();
                }
                if(bis != null){
                    bis.close();
                }
                if(fos !=null){
                    fos.close();
                }
                if(fis != null){
                    fis.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

方式二:字符缓冲流文件拷贝(主要用于文本文件拷贝)

import java.io.*;

public class Test08CopyChar {
    public static void main(String[] args) {
        String src = "d:/a.txt"; //源文件路径 要已经存在 否则会报错
        String des = "d:/b.txt"; //目标文件路径 不需要已经存在 启动程序会自动创建
        copyFile(src, des); // 不加行号
    }
    //不加行号拷贝文件
    public static void copyFile(String src,String des){
        BufferedReader br = null;
        BufferedWriter bw = null;
        try{
            br = new BufferedReader(new FileReader(src));
            bw = new BufferedWriter(new FileWriter(des));
            String temp = "";
            while((temp = br.readLine()) != null){
                bw.write(temp);
                bw.newLine();
            }
            bw.flush();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try{
                if(br != null){
                    br.close();
                }
                if(bw != null){
                    bw.close();
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
    // 添加行号拷贝文件
    public static void copyFileAddLine(String src,String des){
        BufferedReader br = null;
        BufferedWriter bw = null;
        try{
            br = new BufferedReader(new FileReader(src));
            bw = new BufferedWriter(new FileWriter(des));
            String temp = "";
            int i = 1;
            while((temp = br.readLine()) != null){
                bw.write(i+":"+temp);
                bw.newLine();
                i++;
            }
            bw.flush();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try{
                if(br != null){
                    br.close();
                }
                if(bw != null){
                    bw.close();
                }
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
}

2.序列化对象:

介绍

当两个进程远程通信时，彼此可以发送各种类型的数据。 无论是何种类型的数据，都
会以二进制序列的形式在网络上传送。比如，我们可以通过 http 协议发送字符串信息；我
们也可以在网络上直接发送 Java 对象。发送方需要把这个 Java 对象转换为字节序列，才能
在网络上传送；接收方则需要把字节序列再恢复为 Java 对象才能正常读取。

使用的方法

利用对象流和字节流

2.1序列化(输出流): (程序)对象------------>文件

把 Java 对象转换为字节序列的过程称为对象的序列化。

核心代码：

oos = new ObjectOutputStream(new FileOutputStream(desPath)); //使用对象输出流创建文件
oos.writeObject(object); //将对象写入文件中

2.2反序列化(输入流): 文件------------>对象(程序)

把字节序列恢复为 Java 对象的过程称为对象的反序列化。

核心代码：

 ois = new ObjectInputStream(new FileInputStream(desPath)); //使用对象输入流从文件中获取文件数据
 Object object = ois.readObject(); //获取对象

以序列化对象User为例子

import java.io.*;

class User implements Serializable{
    private int userId;
    private String userName;
    private int userAge;

    public User(int userId, String userName, int userAge) {
        this.userId = userId;
        this.userName = userName;
        this.userAge = userAge;
    }
    public User(){}

    public int getUserId() {
        return userId;
    }

    public void setUserId(int userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public int getUserAge() {
        return userAge;
    }

    public void setUserAge(int userAge) {
        this.userAge = userAge;
    }

    @Override
    public String toString() {
        return "User{" +
                "userId=" + userId +
                ", userName='" + userName + '\'' +
                ", userAge=" + userAge +
                '}';
    }
}

// 序列化和反序列化
public class Test12Serializable {
    public static void main(String[] args) {
        String desPath = "d:/data.txt";  //序列化之后文件的存放地址 可根据需求自行更改 这里是绝对路径 window操作系统
        User user = new User(1, "jordan", 50);
        boolean flag =  serializationObject(user, desPath);
        System.out.println("是否序列化成功: "+flag);

        Object object = Deserialization(desPath);
        User u = (User) object;
        //尝试获取对象的一些属性 用于测试
        System.out.println(u.toString());
        System.out.println(u.getUserAge());
    }

    //序列化方法 将对象存入到文件中 对象-----> 文件
    public static boolean serializationObject(Object object, String desPath){
        ObjectOutputStream oos = null;
        try{
            oos = new ObjectOutputStream(new FileOutputStream(desPath)); //使用对象输出流创建文件
            oos.writeObject(object); //将对象写入文件中
            oos.flush(); //将数据从内存中写入到磁盘中
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }finally {
            try {
                if(oos != null){
                    oos.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

    //反序列化方法 从文件中读取对象  文件------>对象
    public static Object Deserialization(String desPath){
        ObjectInputStream ois = null;
        try{
            ois = new ObjectInputStream(new FileInputStream(desPath)); //使用对象输入流从文件中获取文件数据
            Object object = ois.readObject(); //获取对象
            return object;
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }finally {
            try {
                if(ois != null){
                    ois.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

io流详细笔记:链接：https://pan.baidu.com/s/1_2qLob8B7xx_AYSGE1O_Jg
提取码：2022