Java中的浅克隆和深克隆详细分析_深克隆和浅克隆

目录

1、什么是深克隆和浅克隆？        

2、深克隆会带来什么性能问题？

3、采用序列化和反序列化的方式实现深克隆

4、有了深克隆为什么还要浅克隆？

5、Java中除了克隆对象外还有更好的实现对象复制的方式吗？

6、原型模式（克隆）对单例的破环分析

7、Java中的Cloneable接口

---

1、什么是深克隆和浅克隆？        

        在Java中，对象的克隆（Clone）可以使用 Object 类的 clone() 方法实现。Java中的克隆分为浅克隆（Shallow Copy）和深克隆（Deep Copy）两种方式。深克隆和浅克隆是为了在需要克隆一个对象时，提供不同的选择。

        浅克隆会复制对象的所有属性，但是不会复制属性指向的对象，两个对象的属性指向同一个对象。换句话说，浅克隆只是创建了一个新的对象，新对象中的引用类型属性指向的还是原对象中相应的引用类型属性的地址。这样，如果改变一个对象中的引用类型属性，另一个对象的相应引用类型属性也会发生变化。

        深克隆则是将对象及其引用类型属性全部复制一份，两个对象之间不存在指针共享，完全彼此独立。这样就能避免浅克隆带来的问题。

        在 Java 中实现浅克隆，需要实现 Cloneable 接口，并重写 Object 类的 clone() 方法。示例代码如下：

public class Person implements Cloneable {
    private String name;
    private int age;
    private List<String> hobbies;
 
    // 构造方法
 
    @Override
    public Person clone() {
        try {
            return (Person) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }
}

        在 Java 中实现深克隆，需要在对象中引用的其他对象也实现 Cloneable 接口，并重写 Object 类的 clone() 方法。示例代码如下：

public class Person implements Cloneable {
    private String name;
    private int age;
    private List<String> hobbies;
 
    // 构造方法
 
    @Override
    public Person clone() {
        try {
            Person person = (Person) super.clone();
            person.hobbies = new ArrayList<>(hobbies);
            return person;
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
            return null;
        }
    }
}

        在深克隆的实现中，我们需要手动将引用类型的属性复制一份，确保新对象中的属性和原对象中的属性不共享同一引用。

        需要注意的是，在实现深克隆时，被克隆对象的引用类型属性也必须支持克隆，否则将会抛出 CloneNotSupportedException 异常。此外，在实际使用中，为了避免深克隆带来的性能问题，也可以采用序列化和反序列化的方式实现深克隆。

2、深克隆会带来什么性能问题？

        深克隆可能会带来一些性能问题，主要是因为在复制对象的过程中，需要递归地遍历所有的引用类型属性并复制它们的值，这会消耗一定的时间和内存资源。如果对象结构比较复杂或者属性值比较大，深克隆的性能可能会比较低。

        此外，如果对象的属性包含循环引用，深克隆可能会导致无限循环复制，最终导致内存溢出的问题。因此，在进行深克隆时，需要特别注意处理循环引用的情况，避免出现这种问题。

3、采用序列化和反序列化的方式实现深克隆

        采用序列化和反序列化的方式实现深克隆，可以非常方便地实现复杂对象的深度复制，而且不需要手动递归遍历对象的所有属性。// 使用I/O流

        具体实现步骤如下：

1. 让需要进行深克隆的类实现Serializable接口。

2. 创建一个ByteArrayOutputStream对象和一个ObjectOutputStream对象，用于序列化对象。

3. 将需要克隆的对象写入ObjectOutputStream对象，进行序列化。

4. 创建一个ByteArrayInputStream对象和一个ObjectInputStream对象，用于反序列化对象。

5. 从ObjectInputStream对象中读取序列化后的字节流，进行反序列化，得到一个新的对象。

6. 返回新的对象，即为深度克隆后的结果。

        具体实现代码示例：

import java.io.*;
 
public class DeepCopy implements Serializable {
    public Object deepClone() 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 ois.readObject();
    }
}

        在上述代码中，我们通过实现Serializable接口，并使用ObjectOutputStream和ObjectInputStream进行序列化和反序列化的方式，实现了深度克隆的功能。调用deepClone方法可以得到一个与原对象完全相同的新对象，而且新对象与原对象没有任何关联，对新对象的任何修改都不会影响原对象。

        注意序列化和反序列化带来的性能问题：

        序列化和反序列化的主要性能问题是其相对较慢的速度和高的存储空间占用。

        序列化过程需要将对象转换为字节序列，这需要进行大量的计算和IO操作，因此会比较耗时。另外，序列化后的数据通常会占用更多的存储空间，因为序列化过程中会添加一些额外的元数据和类型信息。

        反序列化过程也需要大量的计算和IO操作，因此也会比较耗时。此外，反序列化也可能导致一些潜在的安全问题，因为反序列化过程可能会导致执行一些恶意代码或触发一些漏洞。

        因此，在设计和实现应用程序时，需要考虑序列化和反序列化的性能和安全问题，并根据具体需求选择最适合的实现方式。

4、有了深克隆为什么还要浅克隆？

        虽然深克隆可以创建对象的完全副本，但是在某些情况下，使用浅克隆可能更为合适。主要原因有以下几点：

1. 性能：深克隆的性能通常比浅克隆差。如果对象结构比较复杂，深克隆需要复制的对象数目会很大，会耗费大量时间和资源。而浅克隆只需要复制对象的基本属性，不需要复制整个对象结构，因此通常比深克隆更快。

2. 对象状态的可控性：在某些情况下，我们可能只需要修改对象的一部分属性，而不是整个对象。使用浅克隆可以方便地修改对象的部分属性，而不必复制整个对象。如果使用深克隆，可能会因为对象状态的变化导致复制的对象状态与原对象状态不一致。

3. 对象的关联关系：如果一个对象有对其他对象的引用，使用浅克隆可以保留这些引用关系，而使用深克隆会断开这些引用关系，需要额外处理才能恢复关联关系。

        因此，在实际开发中，我们需要根据具体情况选择适当的克隆方式。如果需要完全复制对象并保留对象之间的引用关系，则使用深克隆；如果只需要复制对象的基本属性，或者需要修改对象的部分属性，则使用浅克隆。

5、Java中除了克隆对象外还有更好的实现对象复制的方式吗？

        除了克隆对象，Java 中还有一些其他的实现对象复制的方式，例如：

1. 使用对象序列化和反序列化：可以将一个对象序列化到一个字节数组中，再从字节数组中反序列化出一个新的对象。这种方式可以实现深克隆，但是需要注意序列化和反序列化的性能问题。

2. 使用 BeanUtils 或 PropertyUtils：Apache Commons BeanUtils 和 PropertyUtils 是一些开源的 Java 库，可以通过反射机制实现对象属性的复制。这种方式只能实现浅克隆，但是实现比较简单，可以节省一些代码量。

3. 使用流式 API：一些流式 API 库（如 Google Guava）提供了一些函数式编程风格的方法，可以方便地对对象进行转换和复制。这种方式也只能实现浅克隆。

6、原型模式（克隆）对单例的破环分析

        在 Java 中，原型模式通常使用 clone() 方法来克隆对象。但是，clone() 方法并不总是完全安全，它可能会破坏单例的特性。

        为了更好地理解这个问题，让我们看一下下面的示例代码：

public class Singleton implements Cloneable {
    private static Singleton instance = new Singleton();
    private Singleton() {}
 
    public static Singleton getInstance() {
        return instance;
    }
 
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
 
public class Client {
    public static void main(String[] args) throws CloneNotSupportedException {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = (Singleton)instance1.clone();
        System.out.println(instance1 == instance2); // false
    }
}

        在这个示例代码中，我们定义了一个 Singleton 类，该类使用饿汉式实现单例模式。然而，由于 Singleton 实现了 Cloneable 接口，并覆盖了 clone() 方法，因此我们可以使用原型模式来创建新的对象实例。在 Client 类中，我们先获取了 Singleton 的实例 instance1，然后克隆了这个实例，得到了一个新的实例 instance2，最后比较这两个实例是否相等。由于 instance2 是通过克隆 instance1 得到的，因此它是一个新的对象实例，与 instance1 不相等，所以输出结果为 false。

        因此，如果需要实现单例模式，应该避免使用原型模式来创建新的对象实例，以确保单例模式的唯一实例限制。

防止原型模式破环单例：

1. 不实现Cloneable接口
2. 如果实现了Cloneable接口，重写clone方法时，返回之前创建的单例对象

改造后的代码如下：

public class Singleton implements Cloneable {
    private static Singleton instance = new Singleton();
    private Singleton() {}
 
    public static Singleton getInstance() {
        return instance;
    }
 
    public Object clone() throws CloneNotSupportedException {
        //return super.clone();
        return getInstance();
    }
}

        总结：如果在应用程序中需要使用单例模式，那么应该保证单例对象只能被实例化一次，不应该通过原型模式来创建新的单例对象。反之亦然，如果需要使用原型模式，那么应该明确需要创建的是一组对象，而不是一个单例对象。

7、Java中的Cloneable接口

        在Java中，Cloneable接口是一种标记接口，用于指示实现类支持克隆。该接口并没有定义任何方法，只是一种约定，要求实现类实现Object类的clone()方法，以支持克隆。

        在Java中，当调用一个对象的clone()方法时，会首先检查该对象是否实现了Cloneable接口，如果没有实现，则会抛出CloneNotSupportedException异常；如果实现了，就会创建一个新的对象，并将原对象的非静态字段值赋给新对象，然后返回新对象。

        需要注意的是，Object类的clone()方法是一个受保护的方法，只有实现了Cloneable接口的类才能调用它。如果要在子类中实现克隆方法，需要覆盖Object类的clone()方法，并在其中调用super.clone()方法，以实现浅克隆。

        另，JVM并没有提供克隆的实现，而是通过Java语言的Cloneable接口实现克隆。当一个类实现了Cloneable接口并且覆盖了Object类的clone()方法时，就可以调用对象的clone()方法进行克隆。在运行时，JVM会通过反射机制获取到对象的clone()方法，然后创建一个新的对象，并将原始对象的属性值复制到新的对象中。需要注意的是，Object类中的clone()方法是浅克隆，因此如果要实现深克隆，需要在具体类中进行处理。 // 所以Java中克隆是通过反射机制实现的