Java实现深克隆，浅克隆

最新推荐文章于 2023-05-16 14:55:31 发布

有错误先debug

最新推荐文章于 2023-05-16 14:55:31 发布

阅读量320

点赞数 4

本文链接：https://blog.csdn.net/qq_42561919/article/details/109467409

版权

什么是浅克隆，什么是深克隆

浅克隆
浅克隆，顾名思义就是把表层的东西复制一份，对于基础数据类型来说，就是把值克隆一份（栈中的值），而对引用数据类型而言，则是复制了一份引用地址。例如

User user1 = new User();
User user2 = user1;

以上代码可以理解为浅克隆，两个对象操作的都是同一个引用地址

深克隆
沈克隆，则比浅克隆要克隆的更加深层次，深克隆相当于是直接又创建了一个属性相同的对象，可以理解为在堆中，把原有空间的值，复制了一份，放到另一个空间，两个对象的引用地址是不相等的
Cloneable接口（Java的浅克隆实现）
创建一个实体类，实现Cloneable接口

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Person  implements Cloneable{

    private String name;
    private String sex;

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    
}

实现接口中clone方法，并将方法访问级别修改为public，这样外部才能够调用，方法中不需要有别的实现，直接调用父级的clone()方法即可，具体的实现交给JVM。
Cloneable接口类似于Serializable接口，只是做一个标记的作用。
这样就实现了Java的浅克隆，编写Main方法测试一下。

    public static void main(String[] args) throws CloneNotSupportedException {
        Person person = new Person("张三","男");
        System.out.println("源对象值："+person);
        Person clone = (Person) person.clone();
        System.out.println("克隆对象值："+clone );
    }

在这里插入图片描述
可以看到，两个对象的所有属性值都是一样的，那么来打印一下两个对象的引用地址

        System.out.println("源对象内存地址："+System.identityHashCode(person));
        System.out.println("克隆对象内存地址："+System.identityHashCode(clone));

在这里插入图片描述
可以看到两个内存地址是不相等的，那么这里就有一个问题，为什么浅克隆之后，两个对象的引用地址是不一样的呢，这里就要看看clone()方法的一个实现过程了。
在源对象在调用了clone方法之后，会先分配一个内存给新的对象，这个内存地址与源对象的相同，然后将源对象中各个属性的值，通过浅克隆拷贝到新对象中，填充完成后，返回一个新的内存地址，再赋值给新的内存对象，所以就导致了源对象和克隆之后的新对象内存地址不相同的情况。
想要验证clone是不是浅拷贝其实很简单，在Person.java实体类中添加一个引用类型的属性
1、新建实体类

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Clothes {

    private String color;

}

2、在Person.java实体中新增一个属性，类型为Clothes .java

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Person  implements Cloneable{

    private String name;
    private String sex;
    private Clothes clothes;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

}

3、结果

    public static void main(String[] args) throws CloneNotSupportedException {
        Person person = new Person("张三","男",new Clothes("红色"));
        System.out.println("源对象值："+person);
        Person clone = (Person) person.clone();
        System.out.println("克隆对象值："+clone );

        System.out.println("源对象内存地址："+System.identityHashCode(person));
        System.out.println("克隆对象内存地址："+System.identityHashCode(clone));

        System.out.println("源对象中clothes属性的内存地址："+System.identityHashCode(person.getClothes()));
        System.out.println("克隆对象中clothes属性的内存地址："+System.identityHashCode(clone.getClothes()));
    }

在这里插入图片描述
可以看到，clothes属性的引用地址是没有变化的，如果person对象或clone对象更改了clothes的属性，都会影响到另一个对象

通过Cloneable接口实现深克隆
想要对Clothes.java类通过Cloneable实现深克隆其实也不难，只需要重复一个对Person.java的操作即可
为Clothes.java类实现Cloneable接口

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Clothes implements Cloneable {

    private String color;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

然后更改Person.java类的clone()方法实现

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Person  implements Cloneable{

    private String name;
    private String sex;
    private Clothes clothes;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person person = (Person)super.clone();
        Clothes clothes = (Clothes) person.getClothes().clone();
        person.setClothes(clothes);
        return person;
    }

}

最后再来看看结果

    public static void main(String[] args) throws CloneNotSupportedException {
        Person person = new Person("张三","男",new Clothes("红色"));
        System.out.println("源对象值："+person);
        Person clone = (Person) person.clone();
        System.out.println("克隆对象值："+clone );

        System.out.println("源对象内存地址："+System.identityHashCode(person));
        System.out.println("克隆对象内存地址："+System.identityHashCode(clone));

        System.out.println("源对象中clothes属性的内存地址："+System.identityHashCode(person.getClothes()));
        System.out.println("克隆对象中clothes属性的内存地址："+System.identityHashCode(clone.getClothes()));
    }

在这里插入图片描述
可以看到clothes属性的内存地址已经变了。
但是这种实现方式，太过于麻烦，每次加一个属性，就要递归一次，而且还需要保证每个类都需要实现Cloneable接口。为了解决这个问题，来看看第二种实现深克隆的方法。

通过Serializable接口实现深克隆
Clothes.java类代码

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Clothes implements Serializable {

    private static final long serialVersionUID = 4267357190457512479L;
    private String color;
}

Person.java类代码

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.*;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Person implements Serializable {

    private static final long serialVersionUID = -3660354394033292895L;

    private String name;
    private String sex;
    private Clothes clothes;

    public Person clone(){
        Person person = null;
        try {
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            ObjectOutputStream outputStream = new ObjectOutputStream(byteArrayOutputStream);
            outputStream.writeObject(this);

            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
            ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
            person = (Person)objectInputStream.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return person;
    }

}

结果

    public static void main(String[] args) {
        Person person = new Person("张三","男",new Clothes("红色"));
        System.out.println("源对象值："+person);
        Person clone = person.clone();
        System.out.println("克隆对象值："+clone );

        System.out.println("源对象内存地址："+System.identityHashCode(person));
        System.out.println("克隆对象内存地址："+System.identityHashCode(clone));

        System.out.println("源对象中clothes属性的内存地址："+System.identityHashCode(person.getClothes()));
        System.out.println("克隆对象中clothes属性的内存地址："+System.identityHashCode(clone.getClothes()));
    }

在这里插入图片描述
为什么序列化会改变对象的内存的，因为Java的序列化，是将对象，转换为流一个的过程。序列化不仅仅是保存一个对象的数据，是会通过递归将对象中所有层次的对象的数据全部保留，也就是全部取出，转换为了流。这个流保存成文件，也可以在网络之间传输，如果保存的是内存地址，那么就不能在网络之间传输也不能保存成文件。
所以也不难理解为什么序列化之后会改变对象的内存地址。对象的所有数据都被复制了一份，取出，转换为流，在读取出来之后，又转换为对象，在堆中重新开辟地址，分配新的内存地址，成为了一个新的对象。

有错误先debug

关注

4
点赞
踩
2

收藏

觉得还不错? 一键收藏
2
评论
Java实现深克隆，浅克隆

在说Cloneable接口前，先将一下什么是浅克隆，什么是深克隆浅克隆浅克隆，顾名思义就是把表层的东西复制一份，对于基础数据类型来说，就是把值克隆一份（栈中的值），而对引用数据类型而言，则是复制了一份引用地址。例如User user1 = new User();User user2 = user1;以上代码可以理解为浅克隆，两个对象操作的都是同一个引用地址深克隆沈克隆，则比浅克隆要克隆的更加深层次，深克隆相当于是直接又创建了一个属性相同的对象，可以理解为在堆中，把原有空间的值，复制了一
复制链接

扫一扫