Comment copier un objet en Java?

Considérez le code ci-dessous:

DummyBean dum = new DummyBean();
dum.setDummy("foo");
System.out.println(dum.getDummy()); // prints 'foo'

DummyBean dumtwo = dum;
System.out.println(dumtwo.getDummy()); // prints 'foo'

dum.setDummy("bar");
System.out.println(dumtwo.getDummy()); // prints 'bar' but it should print 'foo'

Donc, je veux copier le dumà dumtwoet le changement dumsans affecter la dumtwo. Mais le code ci-dessus ne fait pas cela. Quand je change quelque chose dum, le même changement se produit dumtwoégalement.

Je suppose que quand je dis dumtwo = dum, Java copie uniquement la référence . Alors, existe-t-il un moyen de créer une nouvelle copie de dumet de l'affecter à dumtwo?

Créez un constructeur de copie:

class DummyBean {
  private String dummy;

  public DummyBean(DummyBean another) {
    this.dummy = another.dummy; // you can access  
  }
}

Chaque objet a également une méthode de clonage qui peut être utilisée pour copier l'objet, mais ne l'utilisez pas. Il est beaucoup trop facile de créer une classe et de faire une méthode de clonage incorrecte. Si vous voulez faire cela, lisez au moins ce que Joshua Bloch a à dire à ce sujet dans Effective Java .

Basique: copie d'objets en Java.

Supposons un objet- obj1, qui contient deux objets, ContenuObj1 et ContenuObj2 .

copie superficielle: la copie
superficielle crée une nouvelle instanceclasse de la même classe et copie tous les champs dans la nouvelle instance et la renvoie. La classe d'objets fournit une cloneméthode et prend en charge la copie superficielle.

Copie profonde:
une copie profonde se produit lorsqu'un objet est copié avec les objets auxquels il se réfère . L'image ci-dessous montre obj1qu'une copie complète a été effectuée dessus. Non seulement a obj1été copié , mais les objets qu'il contient ont également été copiés. Nous pouvons utiliser Java Object Serializationpour faire une copie complète. Malheureusement, cette approche pose également certains problèmes ( exemples détaillés ).

Problèmes possibles:
clone est difficile à mettre en œuvre correctement.
Il est préférable d'utiliser la copie défensive , les constructeurs de copie (comme réponse @egaga) ou les méthodes d'usine statiques .

1. Si vous avez un objet, que vous savez avoir une clone()méthode publique , mais que vous ne connaissez pas le type de l'objet au moment de la compilation, vous avez un problème. Java a une interface appelée Cloneable. En pratique, nous devons implémenter cette interface si nous voulons créer un objet Cloneable. Object.cloneest protégé , nous devons donc le remplacer par une méthode publique pour qu'il soit accessible.
   
2. Un autre problème se pose lorsque nous essayons de copier en profondeur un objet complexe . Supposons que la clone()méthode de toutes les variables d'objet membre effectue également une copie en profondeur, cela est trop risqué pour une hypothèse. Vous devez contrôler le code dans toutes les classes.
   

Par exemple, org.apache.commons.lang.SerializationUtils aura une méthode pour Deep clone utilisant la sérialisation ( Source ). Si nous devons cloner Bean, il existe deux méthodes utilitaires dans org.apache.commons.beanutils ( Source ).

• cloneBean clonera un bean en fonction des getters et setters de propriété disponibles, même si la classe de bean elle-même n'implémente pas Cloneable.
• copyProperties copiera les valeurs de propriété du bean d'origine vers le bean de destination dans tous les cas où les noms de propriété sont identiques.

Dans le package, import org.apache.commons.lang.SerializationUtils;il y a une méthode:

SerializationUtils.clone(Object);

Exemple:

this.myObjectCloned = SerializationUtils.clone(this.object);

Suivez juste comme ci-dessous:

public class Deletable implements Cloneable{

    private String str;
    public Deletable(){
    }
    public void setStr(String str){
        this.str = str;
    }
    public void display(){
        System.out.println("The String is "+str);
    }
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

et partout où vous voulez obtenir un autre objet, effectuez simplement le clonage. par exemple:

Deletable del = new Deletable();
Deletable delTemp = (Deletable ) del.clone(); // this line will return you an independent
                                 // object, the changes made to this object will
                                 // not be reflected to other object

Pourquoi n'y a-t-il pas de réponse pour utiliser l'API Reflection?

private static Object cloneObject(Object obj){
        try{
            Object clone = obj.getClass().newInstance();
            for (Field field : obj.getClass().getDeclaredFields()) {
                field.setAccessible(true);
                field.set(clone, field.get(obj));
            }
            return clone;
        }catch(Exception e){
            return null;
        }
    }

C'est vraiment simple.

EDIT: inclure un objet enfant via la récursivité

private static Object cloneObject(Object obj){
        try{
            Object clone = obj.getClass().newInstance();
            for (Field field : obj.getClass().getDeclaredFields()) {
                field.setAccessible(true);
                if(field.get(obj) == null || Modifier.isFinal(field.getModifiers())){
                    continue;
                }
                if(field.getType().isPrimitive() || field.getType().equals(String.class)
                        || field.getType().getSuperclass().equals(Number.class)
                        || field.getType().equals(Boolean.class)){
                    field.set(clone, field.get(obj));
                }else{
                    Object childObj = field.get(obj);
                    if(childObj == obj){
                        field.set(clone, clone);
                    }else{
                        field.set(clone, cloneObject(field.get(obj)));
                    }
                }
            }
            return clone;
        }catch(Exception e){
            return null;
        }
    }

J'utilise la bibliothèque JSON de Google pour la sérialiser, puis je crée une nouvelle instance de l'objet sérialisé. Il copie en profondeur avec quelques restrictions:

• il ne peut pas y avoir de références récursives

• il ne copiera pas les tableaux de types disparates

• les tableaux et les listes doivent être tapés ou il ne trouvera pas la classe à instancier

• vous devrez peut-être encapsuler des chaînes dans une classe que vous vous déclarez

J'utilise également cette classe pour enregistrer les préférences utilisateur, les fenêtres et autres éléments à recharger au moment de l'exécution. Il est très simple d'utilisation et efficace.

import com.google.gson.*;

public class SerialUtils {

//___________________________________________________________________________________

public static String serializeObject(Object o) {
    Gson gson = new Gson();
    String serializedObject = gson.toJson(o);
    return serializedObject;
}
//___________________________________________________________________________________

public static Object unserializeObject(String s, Object o){
    Gson gson = new Gson();
    Object object = gson.fromJson(s, o.getClass());
    return object;
}
       //___________________________________________________________________________________
public static Object cloneObject(Object o){
    String s = serializeObject(o);
    Object object = unserializeObject(s,o);
    return object;
}
}

Oui, vous faites simplement référence à l'objet. Vous pouvez cloner l'objet s'il implémente Cloneable.

Consultez cet article wiki sur la copie d'objets.

Reportez-vous ici: Copie d'objets

Ajouter Cloneableet ci-dessous du code à votre classe

public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

Utilisez ceci clonedObject = (YourClass) yourClassObject.clone();

Oui. Vous devez copier en profondeur votre objet.

Cela fonctionne aussi. En supposant un modèle

class UserAccount{
   public int id;
   public String name;
}

Ajoutez d'abord compile 'com.google.code.gson:gson:2.8.1'à votre application> gradle & sync. alors

Gson gson = new Gson();
updateUser = gson.fromJson(gson.toJson(mUser),UserAccount.class);

Vous pouvez exclure l'utilisation d'un champ à l'aide d'un transientmot clé après le modificateur d'accès.

Remarque: il s'agit d'une mauvaise pratique. Ne recommande pas non plus d'utiliser Cloneableou JavaSerializationc'est lent et cassé. Écrire le constructeur de copie pour les meilleures performances réf .

Quelque chose comme

class UserAccount{
        public int id;
        public String name;
        //empty constructor
        public UserAccount(){}
        //parameterize constructor
        public UserAccount(int id, String name) {
            this.id = id;
            this.name = name;
        }

        //copy constructor
        public UserAccount(UserAccount in){
            this(in.id,in.name);
        }
    }

Statistiques de test de 90000 itérations: la
ligne UserAccount clone = gson.fromJson(gson.toJson(aO), UserAccount.class);dure 808 ms

La ligne UserAccount clone = new UserAccount(aO);prend moins de 1 ms

Conclusion: utilisez gson si votre patron est fou et que vous préférez la vitesse. Utilisez le deuxième constructeur de copie si vous préférez la qualité.

Vous pouvez également utiliser le plugin générateur de code de constructeur de copie dans Android Studio.

Voici une explication décente de clone()si vous en avez besoin ...

Ici: clone (méthode Java)

Utilisez un utilitaire de clonage en profondeur:

SomeObjectType copy = new Cloner().deepClone(someObject);

Cela copiera en profondeur tout objet java, vérifiez-le sur https://github.com/kostaskougios/cloning

Le clonage en profondeur est votre réponse, qui nécessite la mise en œuvre de l' Cloneableinterface et le remplacement de la clone()méthode.

public class DummyBean implements Cloneable {

   private String dummy;

   public void setDummy(String dummy) {
      this.dummy = dummy;
   }

   public String getDummy() {
      return dummy;
   }

   @Override
   public Object clone() throws CloneNotSupportedException {
      DummyBean cloned = (DummyBean)super.clone();
      cloned.setDummy(cloned.getDummy());
      // the above is applicable in case of primitive member types like String 
      // however, in case of non primitive types
      // cloned.setNonPrimitiveType(cloned.getNonPrimitiveType().clone());
      return cloned;
   }
}

Tu l'appelleras comme ça DummyBean dumtwo = dum.clone();

Pour ce faire, vous devez cloner l'objet d'une manière ou d'une autre. Bien que Java ait un mécanisme de clonage, ne l'utilisez pas si vous n'en avez pas besoin. Créez une méthode de copie qui effectue le travail de copie pour vous, puis procédez comme suit:

dumtwo = dum.copy();

Voici quelques conseils supplémentaires sur différentes techniques pour réaliser une copie.

Autre que la copie explicite, une autre approche consiste à rendre l'objet immuable (aucune setou d'autres méthodes de mutation). De cette façon, la question ne se pose jamais. L'immuabilité devient plus difficile avec des objets plus grands, mais cet autre aspect est qu'elle vous pousse dans la direction de la division en petits objets cohérents et composites.

Alternative à la méthode de copie du constructeur egaga . Vous avez probablement déjà un POJO, alors ajoutez simplement une autre méthode copy()qui retourne une copie de l'objet initialisé.

class DummyBean {
    private String dummyStr;
    private int dummyInt;

    public DummyBean(String dummyStr, int dummyInt) {
        this.dummyStr = dummyStr;
        this.dummyInt = dummyInt;
    }

    public DummyBean copy() {
        return new DummyBean(dummyStr, dummyInt);
    }

    //... Getters & Setters
}

Si vous en avez déjà un DummyBeanet que vous souhaitez en obtenir une copie:

DummyBean bean1 = new DummyBean("peet", 2);
DummyBean bean2 = bean1.copy(); // <-- Create copy of bean1 

System.out.println("bean1: " + bean1.getDummyStr() + " " + bean1.getDummyInt());
System.out.println("bean2: " + bean2.getDummyStr() + " " + bean2.getDummyInt());

//Change bean1
bean1.setDummyStr("koos");
bean1.setDummyInt(88);

System.out.println("bean1: " + bean1.getDummyStr() + " " + bean1.getDummyInt());
System.out.println("bean2: " + bean2.getDummyStr() + " " + bean2.getDummyInt());

Production:

bean1: peet 2
bean2: peet 2

bean1: koos 88
bean2: peet 2

Mais les deux fonctionnent bien, c'est à vous de décider ...

class DB {
  private String dummy;

  public DB(DB one) {
    this.dummy = one.dummy; 
  }
}

Vous pouvez copier en profondeur automatiquement avec XStream, depuis http://x-stream.github.io/ :

XStream est une bibliothèque simple pour sérialiser des objets en XML et inversement.

Ajoutez-le à votre projet (si vous utilisez maven)

<dependency>
    <groupId>com.thoughtworks.xstream</groupId>
    <artifactId>xstream</artifactId>
    <version>1.3.1</version>                
</dependency>

alors

DummyBean dum = new DummyBean();
dum.setDummy("foo");
DummyBean dumCopy = (DummyBean) XSTREAM.fromXML(XSTREAM.toXML(dum));

Avec cela, vous avez une copie sans avoir besoin d'implémenter une interface de clonage.

public class MyClass implements Cloneable {

private boolean myField= false;
// and other fields or objects

public MyClass (){}

@Override
public MyClass clone() throws CloneNotSupportedException {
   try
   {
       MyClass clonedMyClass = (MyClass)super.clone();
       // if you have custom object, then you need create a new one in here
       return clonedMyClass ;
   } catch (CloneNotSupportedException e) {
       e.printStackTrace();
       return new MyClass();
   }

  }
}

et dans votre code:

MyClass myClass = new MyClass();
// do some work with this object
MyClass clonedMyClass = myClass.clone();

Passez l'objet que vous souhaitez copier et obtenez l'objet que vous souhaitez:

private Object copyObject(Object objSource) {
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(objSource);
            oos.flush();
            oos.close();
            bos.close();
            byte[] byteData = bos.toByteArray();
            ByteArrayInputStream bais = new ByteArrayInputStream(byteData);
            try {
                objDest = new ObjectInputStream(bais).readObject();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return objDest;

    }

Maintenant, analysez l' objDestobjet souhaité.

Codage heureux!

Vous pouvez essayer d'implémenter Cloneableet d'utiliser la clone()méthode; cependant, si vous utilisez la méthode de clonage, vous devez - par défaut - toujours remplacer Objectla public Object clone()méthode de.

Si vous pouvez ajouter une annotation au fichier source, un processeur d'annotation ou un générateur de code comme celui-ci peut être utilisé.

import net.zerobuilder.BeanBuilder

@BeanBuilder
public class DummyBean { 
  // bean stuff
}

Une classe DummyBeanBuilderssera générée, qui a une méthode statique dummyBeanUpdaterpour créer des copies superficielles, de la même manière que vous le feriez manuellement.

DummyBean bean = new DummyBean();
// Call some setters ...
// Now make a copy
DummyBean copy = DummyBeanBuilders.dummyBeanUpdater(bean).done();

Utilisez gsonpour dupliquer un objet.

public static <T>T copyObject(Object object){
    Gson gson = new Gson();
    JsonObject jsonObject = gson.toJsonTree(object).getAsJsonObject();
    return gson.fromJson(jsonObject,(Type) object.getClass());
}

Supposons que j'ai un objet person.

Person copyPerson = copyObject(person);