Java深浅拷贝

心已赠人 2024-02-05 19:00 42阅读 0赞

#### 文章目录 ####

**目录**

文章目录

前言

1) 引用拷贝

2) 对象拷贝

二 . 浅拷贝

1) 拷贝构造方法实现浅拷贝

2) 工厂方法实现浅拷贝

3) clone方法实现浅拷贝

三 . 深拷贝

1) 通过重写clone方法来实现深拷贝

2) 通过对象序列化实现深拷贝

--------------------

## 前言 ##

> 大家好,今天给大家带来的是java中的深浅拷贝

--------------------

**一 . 拷贝的引入**

### 1) 引用拷贝 ###

引用拷贝通常指的是浅拷贝，即只复制了对象本身，而没有复制对象内部的引用对象。这意味着原始对象和拷贝对象仍然共享相同的引用对象

**创建一个指向对象的引用变量的拷贝对象**

>     Student s1 = new Student("张三",23);
>     Student s2 = s1;
>     System.out.println(s1);
>     System.out.println(s2);

![657a07a373a14d76bb52d82c05713be8.png][]

![0f4f5b8541af4faf896a803f9135f976.png][]

### 2) 对象拷贝 ###

创建对象本身的一个副本。

>     Student student = new Student("张三",23);
>     Student otherStudent = (Student)student.clone();
>     System.out.println(student);
>     System.out.println(otherStudent);

![5c24e0067f89453384d34ec3b993c866.png][]

结果分析：由输出结果可以看出，它们的地址是不同的，也就是说创建了新的对象， 而不是把原对象的地址赋给了一个新的引用变量,这就叫做对象拷贝。

![33783c499c214f229ade51626588f365.png][]

Java中的对象拷贝(Object Copy)指的是将一个对象的所有属性（成员变量）拷贝到另一个有着相同类类型的对象中去。

在程序中拷贝对象是很常见的，主要是为了在新的上下文环境中复用现有对象的部分或全部 数据。

Java中的对象拷贝主要分为：浅拷贝(Shallow Copy)、深拷贝(Deep Copy)。

## 二 . 浅拷贝 ##

浅拷贝是指在拷贝对象时，只复制对象本身，而不复制对象内部的引用对象。这意味着原始对象和拷贝对象会共享相同的引用对象，如果引用对象发生改变，原始对象和拷贝对象都会受到影响。

①对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。因为是两份不同的数据，所以对其中一个对象的该成员变量值进行修改，不会影响另一个对象拷贝得到的数据。

②对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。

在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。

浅拷贝的实现方式主要有三种

### 1) 拷贝构造方法实现浅拷贝 ###

class Person {
        Age age;
        String name;
    
        public Person(Age age, String name) {
            this.age = age;
            this.name = name;
        }
    
        /**
         * 拷贝构造方法
         * @param p
         */
        public Person(Person p){
            this.age = p.age;
            this.name = p.name;
        }
    
    }
    
    class Age{
        int age;
    
        public Age(int age) {
            this.age = age;
        }
    }

>     Age age = new Age(18);
>     Person person1 = new Person(age,"张三");
>     Person person2 = new Person(person1);
>     System.out.println(person1);
>     System.out.println(person2);

![ce3200f9e2f7450caa521412c0d60234.png][]

### 2) 工厂方法实现浅拷贝 ###

改变一个方法就行,其他的不变

/**
         * 工厂方法
         * @param p
         */
        public Person clone(Person p){
            return new Person(p.age,p.name);
        }

### 3) clone方法实现浅拷贝 ###

Object类是类结构的根类，其中有一个方法为protected Object clone() throws CloneNotSupportedException，这个方法就是进行的浅拷贝。有了这个浅拷贝模板，我们可以通过调用clone()方法来实现对象的浅拷贝。

但是需要注意：

1、Object类虽然有这个方法，但是这个方法是受保护的（被protected修饰），所以我们无法直接使用。

2、使用clone方法的类必须实现Cloneable接口，否则会抛出异常CloneNotSupportedException。

对于这两点，我们的解决方法是，在要使用clone方法的类中重写clone()方法，通过super.clone()调用Object类中的原clone方法

public class ShallowCopy {
        public static void main(String[] args) throws CloneNotSupportedException {
            Age age = new Age(18);
            Person person1 = new Person(age,"张三");
            Person person2 = (Person)person1.clone();
            System.out.println(person1);
            System.out.println(person2);
        }
    }
    
    class Person implements Cloneable{
        Age age;
        String name;
    
        public Person(Age age, String name) {
            this.age = age;
            this.name = name;
        }
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    }
    
    class Age{
        int age;
    
        public Age(int age) {
            this.age = age;
        }
    }

## 三 . 深拷贝 ##

深拷贝指的是在复制对象时，不仅复制了对象本身，还复制了对象内部的所有引用对象，使得原始对象和拷贝对象完全独立，彼此不会相互影响。

在进行深拷贝时，需要**递归地复制对象及其内部的所有引用对象，确保每个对象都是独立的**

浅拷贝示意图

![b39af9bcadc34adf9ef508cba204c946.png][]

深拷贝示意图

![8594a22d7e94468a8ecb9d70854afcf5.png][]

如果Age对象依然关联其他引用对象,同样也是需要拷贝的

深拷贝的实现方法主要有两种

### 1) **通过重写clone方法来实现深拷贝** ###

class Animal implements Cloneable{
        int age;
        String name;
        Dog dog;
    
        public Animal(int age, String name, Dog dog) {
            this.age = age;
            this.name = name;
            this.dog = dog;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Dog getDog() {
            return dog;
        }
    
        public void setDog(Dog dog) {
            this.dog = dog;
        }
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            Animal animal = (Animal)super.clone();
            animal.setDog((Dog)animal.getDog().clone());
            return animal;
        }
    }
    
    class Dog implements Cloneable{
        int age;
        String name;
    
        public Dog(int age, String name) {
            this.age = age;
            this.name = name;
        }
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    }

>     Animal animal = new Animal(1,"小黄",new Dog(1,"小黄"));
>     Animal cloneAnimal = (Animal) animal.clone();
>     System.out.println(animal);
>     System.out.println(cloneAnimal);
>     System.out.println(animal.getDog());
>     System.out.println(cloneAnimal.getDog());

![258827d9bfb14866bbe7f8afc1557704.png][]

结果分析 : 两个引用animal和cloneAnimal指向不同的两个对象，两个引用animal和cloneAnimal中的两个Dog引用指向的是两个对象，但对Dog对象的修改只能影响animal对象,所以说是深拷贝。

### 2) **通过对象序列化实现深拷贝** ###

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

将对象序列化为字节序列后，默认会将该对象的整个对象图进行序列化，再通过反序列即可完美地实现深拷贝。

参考代码如下

import java.io.*;
    
    class MyClass implements Serializable {
        int number;
    
        public MyClass(int number) {
            this.number = number;
        }
    }
    
    public class DeepCopyExample {
        public static void main(String[] args) {
            // 创建一个原始对象
            MyClass originalObject = new MyClass(10);
    
            // 使用序列化和反序列化进行深拷贝
            MyClass copiedObject = deepCopy(originalObject);
    
            // 修改原始对象的值
            originalObject.number = 20;
    
            // 打印拷贝对象的值，验证是否进行了深拷贝
            System.out.println(copiedObject.number);  // 输出 10
        }
    
        // 使用序列化和反序列化进行深拷贝
        public static <T extends Serializable> T deepCopy(T object) {
            try {
                ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
                ObjectOutputStream output = new ObjectOutputStream(outputStream);
                output.writeObject(object);
    
                ByteArrayInputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray());
                ObjectInputStream input = new ObjectInputStream(inputStream);
                return (T) input.readObject();
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    }

--------------------

**总结**

这篇文章这要给大家介绍了一下java中的深浅拷贝,我们下一篇博客见

[657a07a373a14d76bb52d82c05713be8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/a7033154a9c54642a58f022fd5b41faa.png
[0f4f5b8541af4faf896a803f9135f976.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/5acd067a9f1b45c4b064e651f2fead34.png
[5c24e0067f89453384d34ec3b993c866.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/e19f1ecb0d1040609f030e662a20b58e.png
[33783c499c214f229ade51626588f365.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/6ef755e06c5447c3985a2c9897e9390f.png
[ce3200f9e2f7450caa521412c0d60234.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/ab525eecb506410e8b631e344d4cc5fe.png
[b39af9bcadc34adf9ef508cba204c946.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/aff5ace4b87c4c4a854e4646d8736892.png
[8594a22d7e94468a8ecb9d70854afcf5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/4b1b8bed249e4914bb2c0a017e616f1e.png
[258827d9bfb14866bbe7f8afc1557704.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/3bb625229b55455db1dd3f2a0a4f863e.png