要實(shí)現(xiàn)Java中的深拷貝，必須創(chuàng)建新對(duì)象並遞歸複製所有嵌套對(duì)像以避免共享可變狀態(tài)，具體方法有：1. 使用拷貝構(gòu)造函數(shù)手動(dòng)深拷貝，優(yōu)點(diǎn)是類(lèi)型安全且可控，缺點(diǎn)是繁瑣易出錯(cuò)；2. 利用序列化通過(guò)字節(jié)流實(shí)現(xiàn)深拷貝，能自動(dòng)處理複雜對(duì)象但要求所有類(lèi)實(shí)現(xiàn)Serializable且性能較低；3. 使用Apache Commons Lang的SerializationUtils簡(jiǎn)化序列化過(guò)程，但同樣受限於Serializable要求；4. 借助Gson或Jackson等JSON庫(kù)將對(duì)象序列化為JSON再反序列化，適用於非Serializable類(lèi)但存在性能開(kāi)銷(xiāo)且需字段可訪問(wèn)。選擇依據(jù)包括對(duì)象複雜度、是否可序列化、性能需求及應(yīng)用場(chǎng)景，由於Java無(wú)內(nèi)置深拷貝機(jī)制，需根據(jù)實(shí)際情況選用合適方案。

Copying objects in Java can be tricky because the default behavior ( = ) only copies the reference, not the actual object. If you want a true deep copy , you need to create a new object and recursively copy all nested objects so that the original and the copy don't share any mutable state.

Here's how to perform a deep copy in Java:

1. Manual Deep Copy via Constructor or Method

The most straightforward (but verbose) way is to manually create a new object and copy each field, making sure to deep-copy any mutable nested objects (like lists, arrays, or other custom objects).

 public class Person {
    private String name;
    private Address address; // Assume Address is a mutable class

    public Person(String name, Address address) {
        this.name = name;
        this.address = address;
    }

    // Deep copy constructor
    public Person(Person other) {
        this.name = other.name;
        this.address = new Address(other.address); // Deep copy of Address
    }
}

And in Address :

 public class Address {
    private String city;

    public Address(String city) {
        this.city = city;
    }

    public Address(Address other) {
        this.city = other.city;
    }
}

? Pros : Full control, type-safe, no dependencies
? Cons : Tedious for complex objects, error-prone if you forget a field

2. Using Serialization (Clone via Byte Stream)

A common workaround for deep copying is to serialize and deserialize the object. This creates a true deep copy, provided all nested objects are Serializable .

 import java.io.*;

public class DeepCopy {
    @SuppressWarnings("unchecked")
    public static <T extends Serializable> T deepCopy(T object) {
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(object);
            oos.flush();

            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);

            return (T) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            throw new RuntimeException("Deep copy failed", e);
        }
    }
}

Usage:

 Person original = new Person("Alice", new Address("NYC"));
Person copied = DeepCopy.deepCopy(original);

? Pros : Works for complex nested objects automatically
? Cons :

• All classes must implement Serializable
• Can be slow for large objects
• Static and transient fields are not copied
• Not all objects are serializable (eg, open files, sockets)

3. Using Third-Party Libraries (eg, Apache Commons Lang)

Apache Commons Lang provides a SerializationUtils class that simplifies the serialization approach.

Add to pom.xml :

 <dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version>
</dependency>

Then use:

 Person copied = (Person) SerializationUtils.clone(original);

?? Same limitations as manual serialization — everything must be Serializable .

4. Using JSON or Other Serializers (Gson, Jackson)

You can serialize the object to JSON and then back to an object. This is useful if your objects are already JSON-friendly.

Using Gson :

 Person copied = new Gson().fromJson(new Gson().toJson(original), Person.class);

? Pros : Works with non- Serializable classes, widely used
? Cons :

• Requires all fields to be accessible (via getters/setters)
• May not handle complex object graphs (eg, cycles)
• Performance overhead
• Not truly "type-safe"

Key Points to Remember

• Shallow copy ( clone() without override) only copies field values — references point to the same objects.
• Deep copy ensures no shared mutable state.
• Always consider immutability: if your objects are immutable (eg, String , LocalDateTime ), shallow copy may be sufficient.
• Be cautious with circular references — they can break serialization.

So, which method to choose?

• For simple objects: manual copy with a copy constructor
• For complex but serializable objects: Java serialization or Apache Commons
• For web apps with JSON: Gson/Jackson round-trip
• For performance-critical code: manual deep copy is fastest

Basically, there's no built-in deep copy in Java — you have to roll your own or use a workaround. Pick the method that fits your use case and constraints.

以上是如何在Java中執(zhí)行對(duì)象的深層副本？的詳細(xì)內(nèi)容。更多資訊請(qǐng)關(guān)注PHP中文網(wǎng)其他相關(guān)文章！