Java 深拷贝工具类

已于 2023-02-08 15:53:12 修改
阅读量2.7k 收藏
点赞数 1
分类专栏： Java 文章标签： java 反射 深拷贝
于 2023-02-08 14:25:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ssl267422/article/details/128935087
版权

工具类代码：

package com.example.demo.util;

import org.apache.commons.lang3.StringUtils;

import java.lang.reflect.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;

/**
 * @author ssl
 * @date 2023/2/8 10:03
 */

public class CopyUtil {
    //V3
    public static  <T> T copyClassV3(Object source, Class<T> aClass){
        if (source == null){
            return null;
        }
        T t = null;
        try {
            Class<?> sourceClass = source.getClass();
            GetAll getAll = new GetAll<>(sourceClass).invoke();
            Field[] sourceFields = getAll.getFields();
            HashMap<String, Field> fieldHashMap = new HashMap<>();
            for (Field sourceField : sourceFields) {
                fieldHashMap.put(sourceField.getName(), sourceField);
            }
            getAll = new GetAll<T>(aClass).invoke();
            Field[] fields = getAll.getFields();
            Method[] methods = getAll.getMethods();

            t = aClass.newInstance();
            for (Field field : fields) {
                Field sourceField = fieldHashMap.get(field.getName());
                if (sourceField == null) {
                    continue;
                }else {
                    sourceField.setAccessible(true);
                    Object o = sourceField.get(source);
                    if (o == null && StringUtils.isBlank(String.valueOf(o))){
                        continue;
                    }
                }
                field.setAccessible(true);
                Class<?> type = field.getType();
                Object o = null;
                if (type.isPrimitive() || isBaseType(type)) {
                    o = sourceField.get(source);
                }else {
                    o = copyClassV3(sourceField.get(source), type);
                }
                String methodName = "set" + captureName(field.getName());
                Method declaredMethod = getSetMethod(methodName, methods);
                declaredMethod.invoke(t, o);
            }
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (Exception e){
            e.printStackTrace();
        }
        return t;
    }


    //原始代码升级V2
    public static  <T> T copyClassConcise(Object source, Class<T> aClass){
        if (source == null){
            return null;
        }
        T t = null;
        try {
            Class<?> sourceClass = source.getClass();
            GetAll getAll = new GetAll<>(sourceClass).invoke();
            Field[] sourceFields = getAll.getFields();
            Method[] sourceMethods = getAll.getMethods();
//            Field[] sourceFields = sourceClass.getDeclaredFields();
            HashMap<String, Field> fieldHashMap = new HashMap<>();
            for (Field sourceField : sourceFields) {
                fieldHashMap.put(sourceField.getName(), sourceField);
            }
//            Field[] Fields = aClass.getDeclaredFields();
            getAll = new GetAll<T>(aClass).invoke();
            Field[] fields = getAll.getFields();
            Method[] methods = getAll.getMethods();

            t = aClass.newInstance();
            for (Field field : fields) {
                Field sourceField = fieldHashMap.get(field.getName());
                if (sourceField == null) {
                    continue;
                }else {
                    sourceField.setAccessible(true);
                    Object o = sourceField.get(source);
                    if (o == null && StringUtils.isBlank(String.valueOf(o))){
                        continue;
                    }
                }
                field.setAccessible(true);
                Class<?> type = field.getType();
                Object o = null;
                if (type.isPrimitive() || isBaseType(type)) {
                    o = sourceField.get(source);
                }else {
                    o = copyClassConcise(sourceField.get(source), type);
                }
                String methodName = "set" + captureName(field.getName());
                Method declaredMethod = getSetMethod(methodName, methods);
                declaredMethod.invoke(t, o);
            }
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (Exception e){
            e.printStackTrace();
        }
        return t;
    }

    //根据方法名获得方法
    public static Method getSetMethod(String setMethodName, Method[] methods){
        for (Method method : methods) {
            String name = method.getName();
            if (setMethodName.equals(name)){
                return method;
            }
        }
        return null;
    }


    //原始代码V1
    public static  <T> T copyClass(Object source, Class<T> aClass){
        if (source == null){
            return null;
        }
        T t = null;
        try {
            Class<?> sourceClass = source.getClass();
            Field[] sourceFields = sourceClass.getDeclaredFields();
            HashMap<String, Field> fieldHashMap = new HashMap<>();
            for (Field sourceField : sourceFields) {
                fieldHashMap.put(sourceField.getName(), sourceField);
            }
            Field[] Fields = aClass.getDeclaredFields();
            t = aClass.newInstance();
            for (Field field : Fields) {
                Field sourceField = fieldHashMap.get(field.getName());
                sourceField.setAccessible(true);
                if (sourceField == null) {
                    continue;
                }else {
                    Object o = sourceField.get(source);
                    if (o == null && StringUtils.isBlank(String.valueOf(o))){
                        continue;
                    }
                }
                field.setAccessible(true);

                //方法二
                /*Type type = field.getGenericType();
                String methodName = "";
                if (field.getClass().isPrimitive() || isBaseType(type)) {
                    String typeName = type.getTypeName();
                    if (typeName.equals("java.lang.Boolean") || typeName.equals("boolean")){
                        methodName = "is" + captureName(field.getName());
                    }else {
                        methodName = "set" + captureName(field.getName());
                    }
                    Method declaredMethod = aClass.getDeclaredMethod(methodName, field.getType());
                    declaredMethod.invoke(t, sourceField.get(source));
                }else {
                    Object o = copyClass(sourceField.get(source), field.getType());
                    methodName = "set" + captureName(field.getName());
                    Method declaredMethod = aClass.getDeclaredMethod(methodName, field.getType());
                    declaredMethod.invoke(t, o);
                }*/

                //方法一
                Class<?> type = field.getType();
                String sourceMethodName = "";
                Object o = null;
                if (type.isPrimitive() || isBaseType(type)) {
                    /*String typeName = type.getName();
                    if (typeName.equals("java.lang.Boolean") || typeName.equals("boolean")){
                        sourceMethodName = "is" + captureName(sourceField.getName());
                    }else {
                        sourceMethodName = "get" + captureName(sourceField.getName());
                    }
                    Method sourceClassDeclaredMethod = sourceClass.getDeclaredMethod(sourceMethodName);
                    o = sourceClassDeclaredMethod.invoke(source);*/
                    o = sourceField.get(source);
                }else {
                    o = copyClass(sourceField.get(source), type);
                }
                String methodName = "set" + captureName(field.getName());
                Method declaredMethod = aClass.getDeclaredMethod(methodName, type);
                declaredMethod.invoke(t, o);
            }
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        return t;
    }

    //首字母大写
    public static String captureName(String name) {
        char[] cs=name.toCharArray();
        cs[0]-=32;
        return String.valueOf(cs);
    }

    //判断是否是基本类型的包装类并且兼容泛式的类型
    public static boolean isBaseType(Class<?> type) {
        String className = type.getName();
        if (className.equals("java.lang.Integer") ||
                className.equals("java.lang.Byte") ||
                className.equals("java.lang.Long") ||
                className.equals("java.lang.Double") ||
                className.equals("java.lang.Float") ||
                className.equals("java.lang.Character") ||
                className.equals("java.lang.Short") ||
                className.equals("java.lang.String") ||
                className.equals("java.lang.Boolean") ||
                className.equals("java.lang.Object")) {
            return true;
        }
        return false;
    }

    private static class GetAll<T> {
        private Class<T> aClass;
        private Field[] fields;
        private Method[] methods;

        public GetAll(Class<T> aClass) {
            this.aClass = aClass;
        }

        public Field[] getFields() {
            return fields;
        }

        public Method[] getMethods() {
            return methods;
        }

        public GetAll invoke() {
            List<Field> fieldList = new ArrayList<>();
            List<Method> methodList = new ArrayList<>();
            Class clazz = aClass;
            while (clazz != Object.class){
                fieldList.addAll(new ArrayList<>(Arrays.asList(clazz.getDeclaredFields())));
                methodList.addAll(new ArrayList<>(Arrays.asList(clazz.getDeclaredMethods())));
                clazz = clazz.getSuperclass();
            }
            fields = new Field[fieldList.size()];
            methods = new Method[methodList.size()];
            fieldList.toArray(fields);
            methodList.toArray(methods);
            return this;
        }
    }


    /*public static boolean isBaseType(Type type) {
        String className = String.valueOf(type);
        if (className.contains("java.lang.Integer") ||
                className.contains("java.lang.Byte") ||
                className.contains("java.lang.Long") ||
                className.contains("java.lang.Double") ||
                className.contains("java.lang.Float") ||
                className.contains("java.lang.Character") ||
                className.contains("java.lang.Short") ||
                className.contains("java.lang.String") ||
                className.contains("java.lang.Boolean")) {
            return true;
        }
        return false;
    }*/


}

测试代码：

package com.example.demo.test;

import com.example.demo.entity.*;
import com.example.demo.util.CopyUtil;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.BeanUtils;

/**
 * @author ssl
 * @date 2023/2/8 10:51
 */

public class CopyTest {
    public static void main(String[] args) {
        copyTest4();
    }
    public static void copyTest4(){
        User3 u1 = new User3();
        u1.setId(1L);
        u1.setName("小明");
        u1.setAge(12);
        u1.setB(true);
        u1.setPointXY(new PointXY("12", "13"));
        Notepad<String, String> notepad = new Notepad<>();
        notepad.setKey("key");
        notepad.setValue("value");
        u1.setNotepad(notepad);
        User3 user = CopyUtil.copyClassV3(u1, User3.class);
        System.out.println(u1);
        System.out.println(user);
        System.out.println("=====");
        user.getNotepad().setKey("test");
        user.getPointXY().setX("11");
        user.setAge(11);
        user.setName("小红");
        System.out.println(u1);
        System.out.println(user);

        //其他拷贝类工具
        User3 u2 = new User3();
        BeanUtils.copyProperties(u1, u2);
        System.out.println("-----");
        System.out.println(u2);
        u2.getNotepad().setKey("test");
        u2.getPointXY().setX("11");
        u2.setAge(11);
        u2.setName("小红");
        System.out.println(u1);
        System.out.println(u2);
        
        //其他拷贝类工具
        System.out.println("**********");
        System.out.println(u1);
        ObjectMapper objectMapper = new ObjectMapper();
        User3 u3 = null;
        try {
            u3 = objectMapper.readValue(objectMapper.writeValueAsString(u1), User3.class);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        System.out.println(u3);
        u3.getNotepad().setKey("test2");
        u3.getPointXY().setX("111");
        u3.setAge(112);
        u3.setName("小天");
        System.out.println(u1);
        System.out.println(u3);
    }


    public static void copyTest3(){
        Notepad<Object, Object> n1 = new Notepad<>();
        n1.setKey("key");
        n1.setValue("value");
        Notepad n2 = CopyUtil.copyClassConcise(n1, Notepad.class);
        System.out.println(n1);
        System.out.println(n2);
        System.out.println("------");
        n2.setKey("test");
        n2.setValue("testvalue");
        System.out.println(n1);
        System.out.println(n2);
    }

    public static void copyTest2(){
        User u1 = new User();
        u1.setId(1L);
        u1.setName("小明");
        u1.setAge(12);
        u1.setB(true);
        u1.setPointXY(new PointXY("12", "13"));
        Notepad<String, String> notepad = new Notepad<>();
        notepad.setKey("key");
        notepad.setValue("value");
        u1.setNotepad(notepad);
        User2 user = CopyUtil.copyClassConcise(u1, User2.class);
        System.out.println(u1);
        System.out.println(user);
        System.out.println("====");
        user.getNotepad().setKey("test");
        user.getPointXY().setX("11");
        user.setAge(11);
        user.setName("小红");
        System.out.println(u1);
        System.out.println(user);

        //其他拷贝类工具
        User u2 = new User();
        BeanUtils.copyProperties(u1, u2);
        System.out.println("-----");
        System.out.println(u2);
        u2.getNotepad().setKey("test");
        u2.getPointXY().setX("11");
        u2.setAge(11);
        u2.setName("小红");
        System.out.println(u1);
        System.out.println(u2);

        //其他拷贝类工具
        System.out.println("**********");
        System.out.println(u1);
        ObjectMapper objectMapper = new ObjectMapper();
        User2 u3 = null;
        try {
            u3 = objectMapper.readValue(objectMapper.writeValueAsString(u1), User2.class);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        System.out.println(u3);
        u3.getNotepad().setKey("test2");
        u3.getPointXY().setX("111");
        u3.setAge(112);
        u3.setName("小天");
        System.out.println(u1);
        System.out.println(u3);
    }

    public static void copyTest1(){
        User u1 = new User();
        u1.setId(1L);
        u1.setName("小明");
        u1.setAge(12);
        u1.setB(true);
        u1.setPointXY(new PointXY("12", "13"));
        Notepad<String, String> notepad = new Notepad<>();
        notepad.setKey("key");
        notepad.setValue("value");
        u1.setNotepad(notepad);
        User user = CopyUtil.copyClassConcise(u1, User.class);
        System.out.println(u1);
        System.out.println(user);
        System.out.println("====");
        user.getNotepad().setKey("test");
        user.getPointXY().setX("11");
        user.setAge(11);
        user.setName("小红");
        System.out.println(u1);
        System.out.println(user);

        //其他拷贝类工具
        User u2 = new User();
        BeanUtils.copyProperties(u1, u2);
        System.out.println("-----");
        System.out.println(u2);
        u2.getNotepad().setKey("test");
        u2.getPointXY().setX("11");
        u2.setAge(11);
        u2.setName("小红");
        System.out.println(u1);
        System.out.println(u2);

        //其他拷贝类工具
        System.out.println("**********");
        System.out.println(u1);
        ObjectMapper objectMapper = new ObjectMapper();
        User u3 = null;
        try {
            u3 = objectMapper.readValue(objectMapper.writeValueAsString(u1), User.class);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        System.out.println(u3);
        u3.getNotepad().setKey("test2");
        u3.getPointXY().setX("111");
        u3.setAge(112);
        u3.setName("小天");
        System.out.println(u1);
        System.out.println(u3);
    }
}

转载表明出处

故人颜
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
JAVA 深拷贝工具类
qq_34853463的博客
10-11 507
Java 中基本类型与引用类型的深拷贝
Java 对象深拷贝工具类
m0_67390963的博客
07-27 4995
当我们更新一个对象的时候，如果要记录对象属性的前后变化，那么在更新对象之前，我们应该首先将对象拷贝暂存起来，且这个时候的拷贝一定是深拷贝（内存地址不同的两个对象），因为Java存在对象引用，将一个对象赋值给另外一个对象，他是浅拷贝的（两个不同变量名，但实际内存地址一样的两个对象）的话，也就是说当我们去更新完成属性值的时候，其实是设置的同一个对象，那么这个时候就会导致更新前后无变化的情况。于是，搞一个对象拷贝工具类还是很有必要的。可以看到，批量属性复制也是OK的，拷贝后的集合中每个对象新生成的深拷贝对象。..
Java 对象拷贝工具类
热门推荐
小白一个
07-19 1万+
我们在Java编码中，有时候可能会经常遇到对象拷贝的场景。比如（1）当我们更新一个对象的时候，如果要记录对象属性的前后变化，那么在更新对象之前，我们应该首先将对象拷贝暂存起来，且这个时候的拷贝一定是深拷贝（内存地址不同的两个对象），因为Java存在对象引用，将一个对象赋值给另外一个对象，他是浅拷贝的（两个不同变量名，但实际内存地址一样的两个对象）的话，也就是说当我们去更新完成属性值的时候，其实是设置的同一个对象，那么这个时候就会导致更新前后无变化的情况。............
探索Java深拷贝：从基础到高效实现
最新发布
BASK2312的博客
06-04 1247
探索Java深拷贝：从基础到高效实现在Java中，深拷贝是创建对象副本的过程，同时复制其所有嵌套对象和引用类型的字段。正确实现深拷贝对于确保数据一致性和避免副作用至关重要。在本文中，将探讨几种常见的深拷贝方法，分析它们的实现原理及各自的优缺点。1. 使用Cloneable接口和Object.clone()方法实现原理： Java提供了一个原生的克隆机制，通过实现Cloneable接口并重写Object类的clone()方法，可以创建对象的浅拷贝。为了实现深拷贝，需要在clone()
深拷贝工具类DeepCopyUtil
摸鱼佬的博客
03-11 2966
深拷贝工具类DeepCopyUtil GitHub: link. 欢迎star import lombok.extern.slf4j.Slf4j; import java.io.*; import java.util.List; /** * @author Andon * 2021/11/10 * <p> * 深拷贝 */ @SuppressWarnings({"unchecked", "Duplicates"}) @Slf4j public class DeepCopyUtil
一个JAVA的深拷贝工具类,支持递归
CSDN_Ty的博客
07-26 338
【代码】一个JAVA的深拷贝工具类,支持递归。
Java 类对象深拷贝方法
seuStones's Blog
09-03 2976
Cloneable()接口&Serialized()接口 Java中实现深拷贝的两种方式–——clone() & Serialized 通过反射机制 通过工具类 cglib: beancopier apache: beanutils PropertyUtils 通过FastJson public static<T> T convert(Object src, Cla...
Java对象拷贝之引用拷贝,浅拷贝和深拷贝以及常用工具类
m0_63785629的博客
08-10 2427
引用拷贝：当我们把一个对象赋值给一个新的变量时，赋的其实是该对象的在栈中的地址，而不是堆中的数据。也就是两个对象指向的是同一个存储空间，无论哪个对象发生改变，其实都是改变的存储空间的内容。 浅拷贝：重新在堆中创建内存，拷贝前后对象的基本数据类型互不影响，但拷贝前后对象的引用类型因共享同一块内存，会相互影响。 深拷贝：从堆内存中开辟一个新的区域存放新对象，对对象中的子对象进行递归拷贝,拷贝前后的两个对象互不影响。
Java 会话技术
ssl267422的博客
09-22 1080
会话技术 概念：会话是客户端与服务器之间的一个通信过程，一次会话中可以包含多次请求和响应 一次完整的会话：客户端第一次请求服务器时建立会话，直到任何一方断开为止 作用：在一次会话中的多次请求之间共享数据 分类： 客户端会话技术：Cookie 服务器会话技术：Session 一，Cookie 1.1 概念和基本用法 Cookie是客户端会话技术，它将数据存在客户端（浏览器）中 Cookie的相关方法： 创建，构造函数： Cookie c = new Coo
Java方法/函数
ssl267422的博客
07-27 1072
一，方法的概念 方法也称为函数，是一个专门用于解决某一个问题由若干行语句组成的代码块 好处： 使用方便 提高了代码块复用性 隐藏了功能的实现细节 二，方法组成 public static void main (String[] args) {} 范围（权限）修饰符 其他（特殊）修饰符 返回类型 方法名 参数列表 方法体 范围（权限）修饰符：修饰了方法的使用...
Java Git
ssl267422的博客
12-25 579
1.Git介绍 1.1.什么是Git? Git是一个开源的分布式版本控制系统，可以有效、高速的处理从很小到非常大的项目版本管理。Git 是 LinusTorvalds 为了帮助管理 Linux 内核开发而开发的一个开放源码的版本控制软件。 1.2.Git的历史 1.3.版本控制分类 1.3.1.集中式版本控制 所有的版本数据都保存在服务器上，协同开发者从服务器上同步更新或上传自己的修改。如果不连网则无法使用版本控制器。而且，所有数据都保存在单一的服务器上，有很大的风险这个服务器会损坏，这样就会丢失所有的
Java Maven、Servlet、Filter
ssl267422的博客
09-22 542
一，Maven的简单使用 1.1 Maven的概念 不使用Maven引入依赖存在的问题： jar 包的重复引入 jar 包版本的统一不方便 jar 包版本的升级 使用Maven的好处： 对依赖进行了统一的管理 对项目进行了管理 Maven所存储的依赖在两种不同的仓库中： 本地库 当前计算机 远程库 伺服（额外配置） 公共库（额外配置） 中央库（默认配置） 项目中获
Java jsp
ssl267422的博客
09-22 385
一，JSP 1.1 概念 jsp：java server pages，java 服务器页面 jsp是一种可以在html页面中嵌入java代码的的页面，以.jsp结尾 作用：简化java代码的书写 jsp的本质是一个Servlet，jsp页面在编写代码后第一次被访问时编译执行 一个jsp页面被编译的过程：test.jsp->test_jsp.java->test_jsp.class test.jsp的文件被翻译成了test_jsp.java，这个继承了HttpJspBase，Htt
Java Request、Response
ssl267422的博客
09-22 366
一，请求消息数据的格式 请求行 请求方式：post、get 请求的地址：http://localhost/request_test.html，如果是以get方式提交，请求的数据会拼接在地址后：http://localhost/test?name=123 请求头：由若干个键值对组成 每个键值对的格式：请求头的名称:请求头的值 请求头是客户端在向服务器发起请求时，告知服务器的信息 常见的请求头： user-agent：客户端告知服务器当前浏
Java数据库、JDBC
ssl267422的博客
09-07 245
一，数据库 1.1 概念 数据库就是存储数据的仓库 数据库可以实现数据的持久化存储 数据库的本质是文件系统 1.2 DBMS 数据库管理系统：Database Management System DBMA：数据库管理员 常见的DBMS： MySQL：Oracle公司的中小型数据库 Oracle：Oracle公司的大型数据库 DB2：IBM公司的大型数据 SQLite：移动端的嵌入式的小型数据库 SQLServer：Mircosoft公司的大
Java包和导入、范围修饰符
ssl267422的博客
08-04 201
一，包和导入 包：本质上就是文件夹 作用：提高对类的管理 关键字：package 格式： package xxx.xxx.xxx; 注：package语句必须在文件中的第一条语句 包的命名： 规则：标识符的命名规则 规范： 全小写，用.划分包的层次 一般都是域名倒着写 常见的包名： 测试包：test 工具包：utils、util 业务包：service、business 实体包：entity、domain、bean
Java面向对象的特性
ssl267422的博客
08-04 180
一，封装 生活的封装体：包装盒、机箱 代码中封装体：包、类、方法 好处： 提高了代码的复用性 提高了代码的安全 隐藏了实现的细节 属性的封装： 问题：在对属性进行赋值时，只要赋的值是符合该类型的任何值都是可以完成赋值动作，但是赋的值可能的合法的值。 原因： 只要有对象就可以随意的对属性进行调用 对属性进行赋值时没有对数据进行合理性的判断 解决： 使用关键字private将属性私有化 对外提供这个私有化属性的访问方法 赋值
java深拷贝工具类
09-19
### 回答1： Java中实现深拷贝需要考虑到对象的序列化和反序列化，下面是一个使用Java序列化实现深拷贝的工具类代码示例： ``` import java.io.*; public class DeepCopyUtil { public static <T extends Serializable> T deepCopy(T obj) throws IOException, ClassNotFoundException { 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(); } } ``` 使用示例： ``` public class Main { public static void main(String[] args) throws IOException, ClassNotFoundException { List<Integer> list1 = new ArrayList<>(); list1.add(1); list1.add(2); list1.add(3); List<Integer> list2 = DeepCopyUtil.deepCopy(list1); System.out.println("list1 == list2: " + (list1 == list2)); // false System.out.println("list1.equals(list2): " + list1.equals(list2)); // true } } ``` 该工具类使用了Java的序列化和反序列化，通过将对象序列化成字节数组，再反序列化成新的对象，从而实现了深拷贝。需要注意的是，被复制的对象必须是可序列化的。 ### 回答2： Java中的深拷贝工具类主要用于在创建对象副本时，将对象的所有属性值及其相关的对象也进行拷贝，从而保证新对象的独立性。实现深拷贝的常用方法有两种：序列化与反序列化、自定义深拷贝方法。 首先，使用序列化与反序列化可以实现深拷贝。通过将对象写入流并从流中读取，可以获得该对象的副本。首先，将对象写入OutputStream，再通过ByteArrayInputStream将流转化为字节数组。然后，通过ObjectInputStream将字节数组转化为对象并返回。 其次，可以自定义深拷贝方法。该方法通过递归遍历对象的所有属性，对每个属性实施拷贝操作。如果属性为基本类型，则直接拷贝；如果为引用类型，则递归进行深拷贝。这样可以确保新对象的每个属性都是独立的。 需要注意的是，在使用自定义深拷贝方法时，需要手动实现所有需要拷贝的属性的拷贝逻辑。如果对象的属性过多或复杂，手动实现深拷贝可能会较为繁琐。 综上所述，Java中的深拷贝工具类可以通过序列化与反序列化或自定义深拷贝方法来实现。根据具体需求和对象属性的复杂程度，可以选择合适的方法来完成对象的深拷贝操作。 ### 回答3： Java深拷贝工具类是一个用于复制对象的工具类。深拷贝的概念是指在复制对象时，不仅复制对象本身，还复制对象所引用的其他对象，从而实现完全独立的副本。 在实现深拷贝工具类时，可以通过以下步骤： 1. 首先，需要确保被复制的对象及其引用的对象都实现了Cloneable接口，这样才能使用Object类的clone()方法进行对象的浅拷贝。 2. 创建一个新的空对象，用于存储复制后的对象。 3. 遍历被复制的对象的所有引用类型属性或集合，并逐一进行深拷贝。 4. 对于引用类型属性，可以通过递归调用深拷贝方法，将引用对象复制到新的对象中。 5. 对于集合类型属性，可以创建一个新的集合对象，并将原集合中的每个元素进行深拷贝后添加到新的集合中。 6. 最终返回复制后的对象。 需要注意的是，深拷贝工具类只能完成基本数据类型和引用类型的深拷贝，对于对象内部的静态变量或其他逻辑复杂的情况，需要额外的处理方式。 总之，通过深拷贝工具类，我们可以实现对Java对象及其引用对象的完全独立复制，确保原对象和复制对象之间的数据隔离，适用于需要保护原有数据的场景，如多线程环境下的数据处理。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值