Java对象拷贝之引用拷贝,浅拷贝和深拷贝以及常用工具类_java深拷贝工具类

对象拷贝分为引用拷贝、浅拷贝和深拷贝三种方式。

1、引用拷贝

引用拷贝只是复制了原对象的引用，即两个对象指向同一块内存堆地址。修改其中的一个对象会影响到另一个对象。

代码举例：

Dog dog1=new Dog("小黄",2);
Dog dog2=dog1;//它们指向的是同一个堆中的地址
System.out.println(dog1);
System.out.println(dog2);
dog2.setName("小黑");//如果我改了其中一个对象的属性值，其他对象的属性会跟着变
System.out.println(dog1.getName());
System.out.println(dog2.getName());

输出结果：

Dog@3d075dc0
Dog@3d075dc0
小黑
小黑

1.1基本类型和引用类型

先来了解一下：

在 Java 中数据类型可以分为两大类：基本类型和引用类型。

基本类型也称为值类型，分别是字符类型 char，布尔类型 boolean以及数值类型 byte、short、int、long、float、double。

引用类型则包括类、接口、数组、枚举、字符串等。

Java 将内存空间分为堆和栈。基本类型直接在栈中存储数值，而引用类型是将引用放在栈中，实际存储的值是放在堆中，通过栈中的引用指向堆中存放的数据。

2、浅拷贝

创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值，如果属性是引用类型，拷贝的就是内存地址，原始对象及其副本引用同一个对象。

实现步骤：

1.实现Cloneable接口，标识这个类对象是可以被拷贝的。

2.重写Object继承而来的clone()方法。在clone方法里捕获异常。

代码举例

public class CopyTest {
    public static void main(String[] args) {
        Person p1=new Person("张三",2,new Car(120));
        Person p2=new Person();
        System.out.println("p1的name属性的地址值");
        System.out.println(p1.getName().getClass().getName()+'@'+Integer.toHexString(System.identityHashCode(p1.getName())));
        p2=p1.clone();//浅拷贝
        p2.setAge(20);
        System.out.println("p2的name属性的地址值");
        System.out.println(p2.getName().getClass().getName()+'@'+Integer.toHexString(System.identityHashCode(p2.getName())));
        p2.setName("王五");
        System.out.println("改了之后p2的name属性的地址值");//注意：浅拷贝里，若变量为String字符串，则拷贝其地址引用。但是在修改时，它会从字符串池中重新生成一个新的字符串，原来的对象保持不变。
        System.out.println(p2.getName().getClass().getName()+'@'+Integer.toHexString(System.identityHashCode(p2.getName())));//这就是为什么它改了值，地址跟原先不一样了。
        System.out.println("p1的car的引用地址"+p1.car);
        p2.car.setMoney(1);//变量是一个实例对象，则拷贝其地址引用,p2和p1公有的
        System.out.println("p2的car的引用地址"+p2.car);
        System.out.println(p1);
        System.out.println(p2);
    }
}
class Person implements Cloneable{
   private String name;
   private   int age;
    Car car;
   //省略对应的构造函数，getter和setter方法
   @Override
    protected Person clone() {
        Person person=null;
        try {
           person= (Person) (super.clone());
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return person;
    }
//省略toString方法
}
class Car{
   private int money;
//省略对应的构造函数，getter和setter方法
}

答案：

注意：浅拷贝里，若变量为String字符串，则拷贝其地址引用。但是在修改时，它会从字符串池中重新生成一个新的字符串，原来的对象保持不变。

3、深拷贝

深拷贝是一种完全拷贝，无论是基本类型还是引用类型都会完完全全的拷贝一份，在内存中生成一个新的对象。简单点说就是拷贝对象和被拷贝对象没有任何关系，互不影响。

在上面浅拷贝那个代码里，显然，我们不希望p2和p1共用一个car对象，可以用下面两种方法去解决。

一、通过重写方法来实现深拷贝

与通过重写clone方法实现浅拷贝的基本思路一样，让每个引用类型属性内部都重写clone() 方法，最后在最顶层的类的重写的c1one方法中调用所有的clone方法即可实现深拷贝。

浅拷贝代码改进

public class BeanUtilsTest {
    public static void main(String[] args) {
        Person p1=new Person("张三",2,new Car(120));
        Person p2=new Person();
        p2=p1.clone();
        p2.setAge(20);
        p2.setName("王五");
        System.out.println("p1的car的引用地址"+p1.car);
        p2.car.setMoney(1);//变量是一个实例对象，则拷贝其地址引用,p2和p1公有的
        System.out.println("p2的car的引用地址"+p2.car);
        System.out.println(p1);
        System.out.println(p2);
    }
}
class Person implements Cloneable{
   private String name;
   private   int age;
    Car car;
//省略对应的构造函数，getter和setter方法
    @Override
    protected Person clone() {
        Person person=null;
        try {
           person= (Person) (super.clone());
           person.car=person.car.clone(); //调用
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return person;
    }
//省略toString方法
}
class Car implements Cloneable{
   private int money;
//省略对应的构造函数，getter和setter方法
    @Override
    protected Car clone(){//在car里重写clone方法
        Car car=null;
        try {
           car=(Car)(super.clone());
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return car;
    }
}

答案：

虽然层次调用clone方法可以实现深拷贝，但是代码量太大，特别是针对属性数量比较多，层次比较深的类而言，每个类都要重写clone方法太过于繁琐。

二、通过对象序列化实现深拷贝

序列化是将对象写到流中便于传输，而反序列化则是把对象从流中读取出来。无论嵌套多少个引用类型，序列化都能实现深拷贝。

注意每个需要序列化的类都要实现 Serializable 接口，如果有某个属性不需要序列化，可以将其声明为 transient，即将其排除在克隆属性之外。

代码举例：

public class BeanUtilsTest {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Person p1=new Person("张三",2,new Car(120));
         //序列化
        ByteArrayOutputStream bos=new ByteArrayOutputStream();//字节数组容器
        ObjectOutputStream oos=new ObjectOutputStream(bos);
        oos.writeObject(p1);//把p1转换为字节序列
    //注意，这个序列化和反序列化过程最好写在一个方法里面
        
        //反序列化
        ObjectInputStream ois=new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()));
        Person p2=(Person)ois.readObject();
        
        p2.setAge(20);
        p2.setName("王五");
        System.out.println("p1的car的引用地址"+p1.car);
        p2.car.setMoney(1);//变量是一个实例对象，则拷贝其地址引用,p2和p1公有的
        System.out.println("p2的car的引用地址"+p2.car);
        System.out.println(p1);
        System.out.println(p2);
    }
}
class Person implements Serializable{
   private String name;
   private   int age;
    Car car;
//省略对应的构造函数，getter和setter方法
//省略toString方法
}
class Car implements Serializable{
   private int money;
   //省略对应的构造函数，getter和setter方法
}

答案：

序列化是把堆内存中的 Java 对象数据，通过某种方式把对象存储到磁盘文件中或者传递给其他网络节点（在网络上传输）。而反序列化则是把磁盘文件中的对象数据或者把网络节点上的对象数据，恢复成Java对象模型的过程。

总结

• 引用拷贝：当我们把一个对象赋值给一个新的变量时，赋的其实是该对象的在栈中的地址，而不是堆中的数据。也就是两个对象指向的是同一个存储空间，无论哪个对象发生改变，其实都是改变的存储空间的内容。
• 浅拷贝：重新在堆中创建内存，拷贝前后对象的基本数据类型互不影响，但拷贝前后对象的引用类型因共享同一块内存，会相互影响。
• 深拷贝：从堆内存中开辟一个新的区域存放新对象，对对象中的子对象进行递归拷贝,拷贝前后的两个对象互不影响。

4、常用拷贝工具类

后续更新....