Comment faire une copie profonde d'un objet en Java?

Quelques personnes ont mentionné utiliser ou remplacer Object.clone(). Ne pas le faire. Object.clone() a quelques problèmes majeurs, et son utilisation est déconseillée dans la plupart des cas. Veuillez consulter l'article 11, de" Effective Java " par Joshua Bloch pour une réponse complète. Je crois que vous pouvez utiliser en toute sécurité Object.clone() sur les tableaux de type primitif, mais en dehors de cela, vous devez être judicieux pour utiliser et remplacer correctement le clone.

Les schémas qui reposent sur la sérialisation (XML ou autre) sont kludgy.

Il n'y a pas facile réponse ici. Si vous souhaitez copier en profondeur un objet, vous devrez parcourir le graphique de l'objet et copier explicitement chaque objet enfant via le constructeur de copie de l'objet ou une méthode d'usine statique qui à son tour copie en profondeur l'objet enfant. Les immutables (par exemple String s) n'ont pas besoin d'être copiés. En aparté, vous devriez privilégier l'immutabilité pour cette raison.

Vous pouvez faire une copie profonde avec la sérialisation sans créer de fichiers.

Votre objet que vous souhaitez copie en profondeur devra implement serializable. Si la classe n'est pas finale ou ne peut pas être modifiée, étendez la classe et implémentez serializable.

Convertir votre classe en un flux d'octets:

ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(object);
oos.flush();
oos.close();
bos.close();
byte[] byteData = bos.toByteArray();

Restaurer votre classe à partir d'un flux d'octets:

ByteArrayInputStream bais = new ByteArrayInputStream(byteData);
(Object) object = (Object) new ObjectInputStream(bais).readObject();

Vous pouvez effectuer un clone profond basé sur la sérialisation en utilisant org.apache.commons.lang3.SerializationUtils.clone(T) dans Apache Commons Lang, mais attention-les performances sont abyssales.

En général, il est recommandé d'écrire vos propres méthodes de clonage pour chaque classe d'un objet dans le graphe d'objet nécessitant un clonage.

Une façon d'implémenter deep copy consiste à ajouter des constructeurs de copie à chaque classe associée. Un constructeur de copie prend une instance de 'this' comme argument unique et en copie toutes les valeurs. Pas mal de travail, mais assez simple et sûr.

EDIT: notez que vous n'avez pas besoin d'utiliser des méthodes accessor pour lire les champs. Vous pouvez accéder directement à tous les champs car l'instance source est toujours du même type que l'instance avec le constructeur copy. Évident mais pourrait être négliger.

Exemple:

public class Order {

    private long number;

    public Order() {
    }

    /**
     * Copy constructor
     */
    public Order(Order source) {
        number = source.number;
    }
}


public class Customer {

    private String name;
    private List<Order> orders = new ArrayList<Order>();

    public Customer() {
    }

    /**
     * Copy constructor
     */
    public Customer(Customer source) {
        name = source.name;
        for (Order sourceOrder : source.orders) {
            orders.add(new Order(sourceOrder));
        }
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Edit: Notez que lorsque vous utilisez des constructeurs de copie, vous devez connaître le type d'exécution de l'objet que vous copiez. Avec l'approche ci-dessus, vous ne pouvez pas facilement copier une liste mixte (vous pourrez peut-être le faire avec du code de réflexion).

Apache commons offre un moyen rapide de cloner en profondeur un objet.

My_Object object2= org.apache.commons.lang.SerializationUtils.clone(object1);

Vous pouvez utiliser une bibliothèque qui a une API simple et effectue un clonage relativement rapide avec réflexion (devrait être plus rapide que les méthodes de sérialisation).

Cloner cloner = new Cloner();

MyClass clone = cloner.deepClone(o);
// clone is a deep-clone of o

XStream est vraiment utile dans de tels cas. Voici un code simple pour faire du clonage

private static final XStream XSTREAM = new XStream();
...

Object newObject = XSTREAM.fromXML(XSTREAM.toXML(obj));

Une approche très facile et simple consiste à utiliser Jackson JSON pour sérialiser un objet Java complexe en JSON et le relire.

Http://wiki.fasterxml.com/JacksonInFiveMinutes

Utiliser XStream(http://x-stream.github.io/). Vous pouvez même contrôler les propriétés que vous pouvez ignorer via des annotations ou en spécifiant explicitement le nom de la propriété à la classe XStream. De plus, vous n'avez pas besoin d'implémenter une interface clonable.

La copie profonde ne peut être effectuée qu'avec le consentement de chaque classe. Si vous avez le contrôle sur la hiérarchie des classes, vous pouvez implémenter l'interface clonable et implémenter la méthode Clone. Sinon, il est impossible de faire une copie profonde en toute sécurité car l'objet peut également partager des ressources non-données (par exemple, des connexions à la base de données). En général, cependant, la copie profonde est considérée comme une mauvaise pratique dans l'environnement Java et doit être évitée via les pratiques de conception appropriées.

import com.thoughtworks.xstream.XStream;

public class deepCopy {
    private static  XStream xstream = new XStream();

    //serialize with Xstream them deserialize ...
    public static Object deepCopy(Object obj){
        return xstream.fromXML(xstream.toXML(obj));
    }
}

Pour les objets compliqués et lorsque les performances ne sont pas significatives, j'utilise une bibliothèque json, comme gson pour sérialiser l'objet json texte, puis désérialiser le texte pour obtenir un nouvel objet.

Gson qui basé sur la réflexion fonctionnera dans la plupart des cas, sauf que transient les champs ne seront pas copiés et les objets avec référence circulaire avec cause StackOverflowError.

public static <T> T Copy(T AnObject, Class<T> ClassInfo)
{
    Gson gson = new GsonBuilder().create();
    String text = gson.toJson(AnObject);
    T newObject = gson.fromJson(text, ClassInfo);
    return newObject;
}
public static void main(String[] args)
{
    String originalObject = "hello";
    String copiedObject = Copy(originalObject, String.class);

}

J'ai utilisé Dozerpour cloner des objets java et c'est génial à cela , La bibliothèque Kryo est une autre excellente alternative.

Pour les utilisateurs de Spring Framework. Utilisation de la classe org.springframework.util.SerializationUtils:

@SuppressWarnings("unchecked")
public static <T extends Serializable> T clone(T object) {
     return (T) SerializationUtils.deserialize(SerializationUtils.serialize(object));
}

1)

public static Object deepClone(Object object) {
   try {
     ByteArrayOutputStream baos = new ByteArrayOutputStream();
     ObjectOutputStream oos = new ObjectOutputStream(baos);
     oos.writeObject(object);
     ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
     ObjectInputStream ois = new ObjectInputStream(bais);
     return ois.readObject();
   }
   catch (Exception e) {
     e.printStackTrace();
     return null;
   }
 }

2)

    // (1) create a MyPerson object named Al
    MyAddress address = new MyAddress("Vishrantwadi ", "Pune", "India");
    MyPerson al = new MyPerson("Al", "Arun", address);

    // (2) make a deep clone of Al
    MyPerson neighbor = (MyPerson)deepClone(al);

Ici, votre classe MyPerson et MyAddress doivent implémenter l'interface serilazable

BeanUtils fait un très bon travail de clonage en profondeur des haricots.

BeanUtils.cloneBean(obj);