java中深拷贝,浅拷贝

本是古典何须时尚 2023-10-14 18:26 44阅读 0赞

在Java中，对象的拷贝可以分为深拷贝和浅拷贝两种方式。

1.  浅拷贝（Shallow Copy）： 浅拷贝是指创建一个新的对象，新对象的属性和原对象的属性都指向同一内存地址。换句话说，只是复制了对象的引用而已。 在Java中，可以通过实现Cloneable接口并重写clone()方法来实现浅拷贝。示例代码如下：

javaCopy codeclass Person implements Cloneable {
        private String name;
        
        public Person(String name) {
            this.name = name;
        }
        
        public void setName(String name) {
            this.name = name;
        }
        
        public String getName() {
            return name;
        }
        
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    }
    // 测试
    Person person1 = new Person("Alice");
    Person person2 = (Person) person1.clone();
    System.out.println(person1 == person2);  // false
    System.out.println(person1.getName());   // Alice
    System.out.println(person2.getName());   // Alice
    person2.setName("Bob");
    System.out.println(person1.getName());   // Alice
    System.out.println(person2.getName());   // Bob

从上述代码中可以看出，person1和person2是两个不同的对象，但它们的name属性指向同一内存地址。当修改person2的name属性时，person1的name属性并不会受到影响。 2. 深拷贝（Deep Copy）： 深拷贝是指创建一个新的对象，新对象的属性和原对象的属性都是独立的，即拷贝了对象的所有内容。在Java中，可以通过实现Serializable接口并通过序列化和反序列化来实现深拷贝。示例代码如下：

javaCopy codeimport java.io.*;
    class Person implements Serializable {
        private String name;
        
        public Person(String name) {
            this.name = name;
        }
        
        public void setName(String name) {
            this.name = name;
        }
        
        public String getName() {
            return name;
        }
        
        public Person deepCopy() throws IOException, ClassNotFoundException {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(this);
            
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            return (Person) ois.readObject();
        }
    }
    // 测试
    Person person1 = new Person("Alice");
    Person person2 = person1.deepCopy();
    System.out.println(person1 == person2);  // false
    System.out.println(person1.getName());   // Alice
    System.out.println(person2.getName());   // Alice
    person2.setName("Bob");
    System.out.println(person1.getName());   // Alice
    System.out.println(person2.getName());   // Bob

从上述代码中可以看出，person1和person2是两个不同的对象，它们的name属性分别指向不同的内存地址。当修改person2的name属性时，person1的name属性不会受到影响。这就是深拷贝的特点。

好的，以下是深拷贝和浅拷贝的代码示例： 浅拷贝示例：

javaCopy codeclass Person implements Cloneable {
        private String name;
        
        public Person(String name) {
            this.name = name;
        }
        
        public void setName(String name) {
            this.name = name;
        }
        
        public String getName() {
            return name;
        }
        
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    }
    public class Main {
        public static void main(String[] args) throws CloneNotSupportedException {
            Person person1 = new Person("Alice");
            Person person2 = (Person) person1.clone();
            
            System.out.println(person1 == person2);  // false
            System.out.println(person1.getName());   // Alice
            System.out.println(person2.getName());   // Alice
            
            person2.setName("Bob");
            
            System.out.println(person1.getName());   // Alice
            System.out.println(person2.getName());   // Bob
        }
    }

深拷贝示例：

javaCopy codeimport java.io.*;
    class Person implements Serializable {
        private String name;
        
        public Person(String name) {
            this.name = name;
        }
        
        public void setName(String name) {
            this.name = name;
        }
        
        public String getName() {
            return name;
        }
        
        public Person deepCopy() throws IOException, ClassNotFoundException {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(this);
            
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            return (Person) ois.readObject();
        }
    }
    public class Main {
        public static void main(String[] args) throws IOException, ClassNotFoundException {
            Person person1 = new Person("Alice");
            Person person2 = person1.deepCopy();
            
            System.out.println(person1 == person2);  // false
            System.out.println(person1.getName());   // Alice
            System.out.println(person2.getName());   // Alice
            
            person2.setName("Bob");
            
            System.out.println(person1.getName());   // Alice
            System.out.println(person2.getName());   // Bob
        }
    }

这两个示例分别展示了浅拷贝和深拷贝的用法和效果。

**目录**

Java中深拷贝和浅拷贝

什么是深拷贝和浅拷贝？

如何实现深拷贝和浅拷贝？

浅拷贝的实现

深拷贝的实现

总结

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

## Java中深拷贝和浅拷贝 ##

在Java编程中，我们经常需要对对象进行拷贝操作。拷贝操作可以分为深拷贝和浅拷贝两种类型。本文将介绍深拷贝和浅拷贝的概念、区别以及如何在Java中实现它们。

## 什么是深拷贝和浅拷贝？ ##

*  浅拷贝：浅拷贝是指创建一个新对象，然后将原始对象的字段值复制给新对象。新对象和原始对象共享相同的引用类型的字段。简而言之，浅拷贝只复制对象的引用，而不复制对象本身。
 *  深拷贝：深拷贝是指创建一个新对象，并且复制原始对象的所有字段值。深拷贝是完全独立于原始对象的，即使原始对象的字段引用了其他对象，深拷贝也会为这些字段创建新的对象。

## 如何实现深拷贝和浅拷贝？ ##

### 浅拷贝的实现 ###

在Java中，实现浅拷贝最简单的方式是使用`clone()`方法。这个方法是定义在`Object`类中的，所有的类都继承了这个方法。

javaCopy codeclass MyClass implements Cloneable {
        private int value;
        private MyObject obj;
        public MyClass(int value, MyObject obj) {
            this.value = value;
            this.obj = obj;
        }
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    }

在上面的示例中，`MyClass`实现了`Cloneable`接口，并重写了`clone()`方法。通过调用`super.clone()`方法，可以实现浅拷贝。

### 深拷贝的实现 ###

要实现深拷贝，需要手动复制对象的所有字段，并且对引用类型的字段也进行深拷贝。以下是一个使用深拷贝的示例。

在上面的示例中，`MyClass`实现了`Cloneable`接口，并重写了`clone()`方法。在`clone()`方法中，我们首先调用`super.clone()`进行浅拷贝，然后对引用类型的字段`obj`进行深拷贝，确保新对象和原始对象完全独立。

## 总结 ##

深拷贝和浅拷贝都是在Java中对对象进行拷贝的概念。浅拷贝只复制对象的引用，而不复制对象本身；深拷贝复制对象的所有字段，包括引用类型的字段。在Java中，可以使用`clone()`方法实现浅拷贝，但要实现深拷贝需要手动复制对象的所有字段，并对引用类型字段进行深拷贝。根据实际需求选择合适的拷贝方式，确保程序的正确运行。