Come copio un oggetto in Java?

Considera il codice seguente:

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'

Quindi, voglio copiare il dumper dumtwoe il cambiamento dumsenza alterare il dumtwo. Ma il codice sopra non lo sta facendo. Quando cambio qualcosa dum, succede dumtwoanche lo stesso cambiamento .

Immagino, quando dico dumtwo = dum, Java copia solo il riferimento . Quindi, c'è un modo per creare una nuova copia dume assegnarla a dumtwo?

Crea un costruttore di copie:

class DummyBean {
  private String dummy;

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

Ogni oggetto ha anche un metodo clone che può essere usato per copiare l'oggetto, ma non usarlo. È troppo facile creare una classe e fare un metodo di clonazione improprio. Se hai intenzione di farlo, leggi almeno quello che Joshua Bloch ha da dire al riguardo in Effective Java .

Base: Copia di oggetti in Java.

Supponiamo che un oggetto obj1contenga due oggetti, contenuteObj1 e contenuteObj2 .

copia superficiale: la copia
superficiale crea una nuova instancedella stessa classe e copia tutti i campi nella nuova istanza e la restituisce. La classe di oggetti fornisce un clonemetodo e fornisce supporto per la copia superficiale.

Copia profonda:
una copia profonda si verifica quando un oggetto viene copiato insieme agli oggetti a cui si riferisce . L'immagine sotto mostra obj1dopo che è stata eseguita una copia profonda su di essa. Non solo è obj1stato copiato , ma anche gli oggetti in esso contenuti sono stati copiati. Possiamo usare Java Object Serializationper fare una copia profonda. Sfortunatamente, anche questo approccio presenta alcuni problemi ( esempi dettagliati ).

Possibili problemi:
clone è difficile da implementare correttamente.
È meglio usare la copia difensiva , i costruttori di copie (come risposta @egaga) o i metodi di fabbrica statici .

1. Se hai un oggetto, sai che ha un clone()metodo pubblico , ma non conosci il tipo di oggetto al momento della compilazione, allora hai un problema. Java ha un'interfaccia chiamata Cloneable. In pratica, dovremmo implementare questa interfaccia se vogliamo creare un oggetto Cloneable. Object.cloneè protetto , quindi dobbiamo sostituirlo con un metodo pubblico affinché sia ​​accessibile.
   
2. Un altro problema sorge quando proviamo a copiare in profondità un oggetto complesso . Supponiamo che anche il clone()metodo di tutte le variabili oggetto membro esegua una copia approfondita, questo è troppo rischioso di un'ipotesi. È necessario controllare il codice in tutte le classi.
   

Ad esempio org.apache.commons.lang.SerializationUtils avrà un metodo per il clone Deep usando la serializzazione ( Source ). Se abbiamo bisogno di clonare Bean, ci sono un paio di metodi di utilità in org.apache.commons.beanutils ( Fonte ).

• cloneBean Clonerà un bean in base ai getter e ai setter di proprietà disponibili, anche se la classe bean stessa non implementa Cloneable.
• copyProperties copierà i valori delle proprietà dal bean di origine nel bean di destinazione per tutti i casi in cui i nomi delle proprietà sono uguali.

Nel pacchetto import org.apache.commons.lang.SerializationUtils;c'è un metodo:

SerializationUtils.clone(Object);

Esempio:

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

Segui come di seguito:

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();
    }
}

e ovunque tu voglia ottenere un altro oggetto, esegui semplicemente la clonazione. per esempio:

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

Perché non esiste una risposta per l'utilizzo dell'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;
        }
    }

È davvero semplice

EDIT: include l'oggetto figlio tramite ricorsione

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;
        }
    }

Uso la libreria JSON di Google per serializzarla, quindi creo una nuova istanza dell'oggetto serializzato. Fa copia profonda con alcune restrizioni:

• non ci possono essere riferimenti ricorsivi

• non copia array di tipi diversi

• matrici ed elenchi devono essere digitati o non troveranno la classe da istanziare

• potresti dover incapsulare le stringhe in una classe che ti dichiari

Uso anche questa classe per salvare le preferenze dell'utente, Windows e quant'altro da ricaricare in fase di esecuzione. È molto facile da usare ed 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;
}
}

Sì, stai solo facendo un riferimento all'oggetto. Puoi clonare l'oggetto se lo implementa Cloneable.

Dai un'occhiata a questo articolo wiki sulla copia di oggetti.

Fare riferimento qui: Copia oggetto

Aggiungi Cloneablee sotto il codice alla tua classe

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

Usa questo clonedObject = (YourClass) yourClassObject.clone();

Sì. Devi copiare in profondità il tuo oggetto.

Anche questo funziona. Supponendo modello

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

Per prima cosa aggiungi compile 'com.google.code.gson:gson:2.8.1'alla tua app> gradle & sync. Poi

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

Puoi escludere usando un campo usando la transientparola chiave dopo il modificatore di accesso.

Nota: questa è una cattiva pratica. Inoltre, non è consigliabile utilizzare Cloneableo JavaSerializationè lento e rotto. Costruttore di copia di scrittura per le migliori prestazioni rif .

Qualcosa di simile a

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);
        }
    }

Statistiche di prova di 90000 iterazione: la
linea UserAccount clone = gson.fromJson(gson.toJson(aO), UserAccount.class);impiega 808 ms

La linea UserAccount clone = new UserAccount(aO);richiede meno di 1 ms

Conclusione: usa gson se il tuo capo è pazzo e preferisci la velocità. Usa il costruttore della seconda copia se preferisci la qualità.

Puoi anche utilizzare il plug- in del generatore di codice del costruttore della copia in Android Studio.

Ecco una spiegazione decente clone()se alla fine ne hai bisogno ...

Qui: clone (metodo Java)

Utilizzare un'utilità di clonazione profonda:

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

Questo copia in profondità qualsiasi oggetto java, dai un'occhiata a https://github.com/kostaskougios/cloning

Deep Cloning è la tua risposta, che richiede l'implementazione Cloneabledell'interfaccia e l'override del clone()metodo.

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;
   }
}

Lo chiamerai così DummyBean dumtwo = dum.clone();

Per fare ciò devi clonare l'oggetto in qualche modo. Sebbene Java abbia un meccanismo di clonazione, non utilizzarlo se non è necessario. Crea un metodo di copia che funzioni per te, quindi esegui:

dumtwo = dum.copy();

Ecco alcuni consigli su diverse tecniche per realizzare una copia.

Oltre alla copia esplicita, un altro approccio è quello di rendere l'oggetto immutabile (nessun seto altri metodi mutatori). In questo modo la domanda non si pone mai. L'immutabilità diventa più difficile con oggetti più grandi, ma l'altro lato è che ti spinge nella direzione della scissione in piccoli oggetti e compositi coerenti.

Alternativa al metodo di copia del costruttore egaga . Probabilmente hai già un POJO, quindi aggiungi un altro metodo copy()che restituisce una copia dell'oggetto inizializzato.

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
}

Se hai già un DummyBeane vuoi una copia:

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());

Produzione:

bean1: peet 2
bean2: peet 2

bean1: koos 88
bean2: peet 2

Ma entrambi funzionano bene, dipende da te ...

class DB {
  private String dummy;

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

Puoi eseguire il deep copy automaticamente con XStream, da http://x-stream.github.io/ :

XStream è una semplice libreria per serializzare oggetti in XML e viceversa.

Aggiungilo al tuo progetto (se usi maven)

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

Poi

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

Con questo hai una copia senza la necessità di implementare alcuna interfaccia di clonazione.

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();
   }

  }
}

e nel tuo codice:

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

Passa l'oggetto che desideri copiare e ottieni l'oggetto che desideri:

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;

    }

Ora analizza l' objDestoggetto desiderato.

Buona programmazione!

Puoi provare a implementare Cloneablee utilizzare il clone()metodo; tuttavia, se usi il metodo clone, dovresti - per impostazione predefinita - sostituire SEMPRE Objectil public Object clone()metodo.

Se è possibile aggiungere un'annotazione al file di origine, è possibile utilizzare un processore di annotazione o un generatore di codice come questo .

import net.zerobuilder.BeanBuilder

@BeanBuilder
public class DummyBean { 
  // bean stuff
}

DummyBeanBuildersVerrà generata una classe , che ha un metodo statico dummyBeanUpdaterper creare copie superficiali, allo stesso modo in cui lo faresti manualmente.

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

Utilizzare gsonper duplicare un oggetto.

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

Si supponga che ho un oggetto person.Così

Person copyPerson = copyObject(person);