常用工具类汇总之Java list＜bean＞的浅拷贝(Shallow Copy)、深拷贝(Deep Copy)工具类封装

最新推荐文章于 2024-07-26 02:51:29 发布

Code神之手

最新推荐文章于 2024-07-26 02:51:29 发布

阅读量1.5k

点赞数 1

分类专栏：常用工具类汇总

本文链接：https://blog.csdn.net/Seven71111/article/details/109056517

版权

常用工具类汇总专栏收录该内容

9 篇文章 0 订阅

订阅专栏

封装工具类

ReplicationBeanUtils

拷贝思路1：

将对象进行序列化，把得到的字节序列写到一个目标输出流中。再从一个源输入流中读取字节序列，再把它们反序列化为一个对象。

拷贝思路2：

将对象转成字符串，再通过json类将String转成对象。

package com.hierway.pmcs.wms.utils;

import com.alibaba.fastjson.JSON;
import org.springframework.beans.BeanUtils;
import org.springframework.util.CollectionUtils;

import java.io.*;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;

/**
 * @Description
 * @Author by mocar小师兄
 * @Date 2020/10/13 16:37
 **/
public class ReplicationBeanUtils {

    /***
     * 功能描述: list<bean> 深拷贝
     * (bean 对象必须序列化，即 implements Serializable)
     * @Author: by mocar
     * @Date: 2020/10/13 16:39
     */
    public static <T> List<T> deepCopyListBean(List<T> src){
        try {
            ByteArrayOutputStream byteOut = new ByteArrayOutputStream();//目标输出流
            ObjectOutputStream out = null;//对象输出流
            out = new ObjectOutputStream(byteOut);
            //对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中
            out.writeObject(src);
            ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
            ObjectInputStream in = new ObjectInputStream(byteIn);//对象输入流
            //readObject()方法从一个源输入流中读取 字节序列，再把它们反序列化为一个对象
            return (List<T>)in.readObject();
        } catch (IOException e) {
            e.printStackTrace();
        }catch (ClassNotFoundException ex) {
            ex.printStackTrace();
        }
        return null;
    }

    /**
     * bean的拷贝
     * @param src
     * @param <T>
     * @return
     */
    public static <T> T shallowCopyBean(T src) {
        T newInstance = null;
        if (src == null) return null;
        try {
            newInstance = (T) src.getClass().newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        BeanUtils.copyProperties(src, newInstance);
        return newInstance;
    }

    /**
     * 深拷贝list对象
     * @param src
     * @param <T>
     * @return
     */
    public static <T> List<T> replicationBeanList(List<T> src){
        if (CollectionUtils.isEmpty(src)) throw new RuntimeException("src object list Can't be empty");
        List<T> list = (List<T>) JSON.parseArray(JSON.toJSONString(src), src.get(0).getClass());
        return list;
    }

    /**
     * 深拷贝Bean对象
     * @param src
     * @param <T>
     * @return
     */
    public static <T> T replicationBean(T src){
        if (src == null) throw new RuntimeException("src object list Can't be empty");
        return (T)JSON.parseObject(JSON.toJSONString(src),src.getClass());
    }

    //返回Type数组，之所以返回Type数组,是因为一个类上有可能出现多个泛型
    public static <T> Class<T> getActualType(List<T> src) {
        //获取到参数化类型
//        Type clazz = o.getClass().getGenericSuperclass();
        Type clazz = src.getClass().getGenericSuperclass();
        ParameterizedType pt = (ParameterizedType)clazz;
        return (Class<T>)pt.getActualTypeArguments()[0];//获取list泛型类

    }
}