JAVA中的深拷贝和浅拷贝

亦凉 2023-06-16 15:56 35阅读 0赞

对于一个对象的拷贝，有很多方法，比如最简单的

就是这个类实现 cloneable接口，实现clone()方法即可，

但是这样是浅拷贝，意思就是对象的基础类型和引用对象的句柄都拷贝过去了

注意 这里说的是引用对象的句柄

但是，学过JVM的都知道，基础类型都是存放在JAVA栈中，

引用类型：句柄存放在栈中，对象是存在放堆中

所以你如果修改1个对象的引用，相当于修改了2个对象的应用。

因为浅拷贝的目标对象和源对象指向的引用成员变量是同一个地方。

所以我们需要深拷贝，意思就是拷贝的时候，同时把引用对象也拷贝出一份

用对象字节流的序列与反序列化很方便，下面是例子

# Student.java #

@Data
    @Builder
    public class Student implements Cloneable,Serializable{
    
        private static final long serialVersionUID = 2L;
    
        private String Name;
        private String sex;
        private Classes classes;
    
        /**
         * 浅拷贝
         * @return
         * @throws CloneNotSupportedException
         */
        @Override
        protected Student clone() throws CloneNotSupportedException {
            return (Student)super.clone();
        }
    
        /**
         * 深度拷贝 == 不管你对象中是值类型部分，还是引用类型部分，我全部拿走
         * 对象字节流的序列与反序列化 ==> 对象完全、深度、彻彻底底的Copy！！！
         * @return
         */
        public Student deepClone(){
    
            // Anything 都是可以用字节流进行表示，记住是任何！
            Student student = null;
            try{
    
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                ObjectOutputStream oos = new ObjectOutputStream(baos);
                // 将当前的对象写入baos【输出流 -- 字节数组】里
                oos.writeObject(this);
    
                // 从输出字节数组缓存区中拿到字节流
                byte[] bytes = baos.toByteArray();
    
                // 创建一个输入字节数组缓冲区
                ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
                // 创建一个对象输入流
                ObjectInputStream ois = new ObjectInputStream(bais);
                // 下面将反序列化字节流 == 重新开辟一块空间存放反序列化后的对象
                student = (Student) ois.readObject();
    
            }catch (Exception e){
                System.out.println(e.getClass()+":"+e.getMessage());
            }
            return  student;
        }
    }

测试类

public static void main(String[] args) throws CloneNotSupportedException {
    
            Classes classes = Classes.builder().classesName("classname")
                    .classesLeavl(1).build();
            Student student1 = Student.builder().Name("aaa")
                                .sex("男").classes(classes).build();
    
            Student student2 = student1.clone();
            classes.setClassesName("classnamenew");
            student1.setName("bbbb");
    
            Student student3 = student1.deepClone();
            classes.setClassesName("classname333");
            student1.setName("cccc");
    
            System.out.println("student1.classes"+student1.getClasses().hashCode());
            System.out.println("student1"+student1.getClasses());
            System.out.println("student2.classes"+student2.getClasses().hashCode());
            System.out.println("student2"+student2.getClasses());
            System.out.println("student3.classes"+student3.getClasses().hashCode());
            System.out.println("student3"+student3.getClasses());
        }

打印结果

student1.classes1185899242  
student1Classes(classesName=classname333, classesLeavl=1)  
student2.classes1185899242  
student2Classes(classesName=classname333, classesLeavl=1)  
student3.classes1189339945  
student3Classes(classesName=classnamenew, classesLeavl=1)

从结果可以看到，student2是student1的浅拷贝对象，修改classes对象时，同时也影响到student2

student3是student1的深拷贝对象，修改classes对象时，不会影响到student3.