To implement deep copy in Java, new objects must be created and all nested objects recursively copy to avoid sharing mutable states. The specific methods include: 1. Manual deep copy using copy constructor. The advantages are type safe and controllable, and the disadvantages are cumbersome and error-prone; 2. Use serialization to achieve deep copy through byte streams, which can automatically process complex objects but require all classes to achieve Serializable and have low performance; 3. Use SerializationUtils of Apache Commons Lang to simplify the serialization process, but is also limited by Serializable requirements; 4. Use JSON libraries such as Gson or Jackson to serialize objects to JSON and deserialize them. It is suitable for non-Serializable classes but has performance overhead and requires fields to be accessible. The selection basis includes object complexity, serialization, performance requirements and application scenarios. Since Java does not have a built-in deep copy mechanism, it is necessary to choose a suitable solution according to actual conditions.

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 copy 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.

The above is the detailed content of How to perform a deep copy of an object in Java?. For more information, please follow other related articles on the PHP Chinese website!