Java 深拷贝（对象和IO流）

import lombok.extern.slf4j.Slf4j;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;



@Slf4j
public class InputStreamCopy {

    /**
     * 深拷贝输入流
     * 通过读取输入流的内容并将其写入新的字节输入流中，从而创建一个与原始输入流 identical 的新输入流
     * 这允许在不从原始数据源继续读取的情况下，多次读取或处理相同的数据
     *
     * @param is 要深拷贝的输入流
     * @return 一个新的 ByteArrayInputStream，其内容与原始输入流相同
     * @throws RuntimeException 如果在拷贝过程中发生错误，将抛出运行时异常
     */
    public static InputStream deepCopyInputStream(InputStream is) {
        // 创建一个字节数组输出流，用于存储从输入流读取的字节
        ByteArrayOutputStream byteBuffer = new ByteArrayOutputStream();
        try {
            // 定义缓冲区大小
            int bufferSize = 1024;
            // 创建缓冲区
            byte[] buffer = new byte[bufferSize];

            // 循环读取输入流数据，直到到达流的末尾
            int len;
            while ((len = is.read(buffer)) != -1) {
                // 将读取到的数据写入字节数组输出流
                byteBuffer.write(buffer, 0, len);
            }
            // 将字节数组输出流转换为字节数组
            byte[] byteArray = byteBuffer.toByteArray();

            // 使用字节数组创建新的字节输入流
            return new ByteArrayInputStream(byteArray);
        } catch (Exception e) {
            // 记录错误日志
            log.error("deepCopyInputStream error", e);
            // 抛出运行时异常，包含错误信息和原因
            throw new RuntimeException("deepCopyInputStream error:" + e.getMessage(), e);
        }
    }

}

import java.io.*;
import java.util.List;



public class DeepCopyUtil {

    public static <T extends Serializable> T deepCopy(T obj) {
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(obj);

            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            return (T) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }

    public static <T extends Serializable> List<T> deepCopyList(List<T> originalList) {
        try {
            // 将 List 对象写入字节流
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
            objectOutputStream.writeObject(originalList);

            // 从字节流中读取 List 对象
            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
            ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
            List<T> copiedList = (List<T>) objectInputStream.readObject();

            return copiedList;
        } catch (IOException | ClassNotFoundException e) {
            throw new RuntimeException("Deep copy failed", e);
        }
    }
}