Jak skopiować obiekt w Javie?

Rozważ poniższy kod:

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'

Tak, chcę skopiować dumdo dumtwoi zmiana dumbez wpływania na dumtwo. Ale powyższy kod tego nie robi. Kiedy coś dumzmieniam, zachodzi dumtworównież ta sama zmiana .

Kiedy mówię dumtwo = dum, Java kopiuje tylko odniesienie . Czy jest więc jakiś sposób na stworzenie nowej kopii dumi przypisanie jej dumtwo?

Utwórz konstruktor kopii:

class DummyBean {
  private String dummy;

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

Każdy obiekt ma również metodę klonowania, której można użyć do skopiowania obiektu, ale nie należy go używać. Zbyt łatwo jest stworzyć klasę i zastosować niewłaściwą metodę klonowania. Jeśli masz zamiar to zrobić, przeczytaj przynajmniej, co Joshua Bloch ma do powiedzenia na ten temat w Effective Java .

Podstawowy: Kopiowanie obiektów w Javie.

Załóżmy obj1, że obiekt- , który zawiera dwa obiekty, zawieraObj1 i zawieraObj2 .

płytkie kopiowanie:
płytkie kopiowanie tworzy nowy instancez tej samej klasy i kopiuje wszystkie pola do nowej instancji i zwraca je. Klasa obiektowa zapewnia clonemetodę i obsługuje płytkie kopiowanie.

Głębokie kopiowanie:
Głęboka kopia występuje, gdy obiekt jest kopiowany wraz z obiektami, do których się odnosi . Poniższe zdjęcie pokazuje obj1po wykonaniu na nim głębokiej kopii. Nie tylko obj1został skopiowany , ale również obiekty w nim zawarte zostały skopiowane. Możemy użyć Java Object Serializationdo wykonania głębokiej kopii. Niestety, takie podejście ma również pewne problemy ( szczegółowe przykłady ).

Możliwe problemy:
clone trudno jest poprawnie wdrożyć.
Lepiej jest używać Defensywnego kopiowania , konstruktorów kopiowania (jako odpowiedź @egaga) lub statycznych metod fabrycznych .

1. Jeśli masz obiekt, o którym wiesz, że ma clone()metodę publiczną , ale nie znasz typu obiektu w czasie kompilacji, masz problem. Java ma interfejs o nazwie Cloneable. W praktyce powinniśmy wdrożyć ten interfejs, jeśli chcemy stworzyć obiekt Cloneable. Object.clonejest chroniony , dlatego musimy go zastąpić publiczną metodą, aby była dostępna.
   
2. Kolejny problem powstaje, gdy staramy głębokie kopiowanie o złożonego obiektu . Załóżmy, że clone()metoda wszystkich zmiennych obiektów składowych również wykonuje głębokie kopiowanie, jest to zbyt ryzykowne z założenia. Musisz kontrolować kod we wszystkich klasach.
   

Na przykład org.apache.commons.lang.SerializationUtils będzie miał metodę głębokiego klonowania przy użyciu serializacji ( źródło ). Jeśli musimy sklonować Bean, istnieje kilka metod narzędziowych w org.apache.commons.beanutils ( Source ).

• cloneBean sklonuje komponent bean na podstawie dostępnych modułów pobierających i ustawiających właściwości, nawet jeśli sama klasa bean nie implementuje funkcji Cloneable.
• copyProperties skopiuje wartości właściwości z komponentu bean źródłowego do komponentu bean docelowego dla wszystkich przypadków, w których nazwy właściwości są takie same.

W pakiecie import org.apache.commons.lang.SerializationUtils;jest metoda:

SerializationUtils.clone(Object);

Przykład:

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

Po prostu wykonaj następujące czynności:

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

i gdziekolwiek chcesz zdobyć inny obiekt, po prostu wykonaj klonowanie. na przykład:

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

Dlaczego nie ma odpowiedzi na użycie interfejsu 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;
        }
    }

To jest naprawdę proste.

EDYCJA: Dołącz obiekt potomny poprzez rekurencję

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

Korzystam z biblioteki Google JSON do serializacji, a następnie tworzę nową instancję serializowanego obiektu. Robi głębokie kopiowanie z kilkoma ograniczeniami:

• nie może być żadnych rekurencyjnych odniesień

• nie kopiuje tablic różnych typów

• tablice i listy powinny być wpisane, w przeciwnym razie nie znajdzie klasy do utworzenia

• może być konieczne enkapsulowanie łańcuchów w klasie, którą sam deklarujesz

Korzystam również z tej klasy do zapisywania preferencji użytkownika, okien i innych elementów, które należy ponownie załadować w czasie wykonywania. Jest bardzo łatwy w użyciu i skuteczny.

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

Tak, właśnie odwołujesz się do obiektu. Możesz sklonować obiekt, jeśli implementuje Cloneable.

Sprawdź ten artykuł wiki na temat kopiowania obiektów.

Zobacz tutaj: Kopiowanie obiektów

Dodaj Cloneablekod poniżej i do swojej klasy

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

Użyj tego clonedObject = (YourClass) yourClassObject.clone();

Tak. Musisz głęboko skopiować swój obiekt.

To też działa. Zakładając model

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

Najpierw dodaj compile 'com.google.code.gson:gson:2.8.1'do swojej aplikacji> gradle & sync. Następnie

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

Możesz wykluczyć użycie pola za pomocą transientsłowa kluczowego po modyfikatorze dostępu.

Uwaga: to zła praktyka. Również nie polecam używać Cloneablelub JavaSerializationJest powolny i uszkodzony. Napisz konstruktor kopiowania dla najlepszej wydajności ref .

Coś jak

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

Statystyki testowe iteracji 90000:
Linia UserAccount clone = gson.fromJson(gson.toJson(aO), UserAccount.class);zajmuje 808ms

Linia UserAccount clone = new UserAccount(aO);zajmuje mniej niż 1 ms

Wniosek: użyj gson, jeśli twój szef jest szalony i wolisz szybkość. Jeśli wolisz jakość, użyj drugiego konstruktora kopii.

Możesz także użyć wtyczki generatora kodu konstruktora w Android Studio.

Oto przyzwoite wyjaśnienie, clone()czy w końcu będziesz go potrzebować ...

Tutaj: klon (metoda Java)

Użyj narzędzia do głębokiego klonowania:

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

Spowoduje to głębokie skopiowanie dowolnego obiektu Java, sprawdź go na https://github.com/kostaskougios/cloning

Głębokie klonowanie jest odpowiedzią, która wymaga implementacji Cloneableinterfejsu i zastąpienia clone()metody.

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

Nazwiesz to tak DummyBean dumtwo = dum.clone();

Aby to zrobić, musisz w jakiś sposób sklonować obiekt. Chociaż Java ma mechanizm klonowania, nie używaj go, jeśli nie musisz. Utwórz metodę kopiowania, która wykonuje kopiowanie, a następnie wykonaj następujące czynności:

dumtwo = dum.copy();

Oto kilka porad dotyczących różnych technik tworzenia kopii.

Oprócz jawnego kopiowania, innym podejściem jest uczynienie obiektu niezmiennym (brak setlub inne metody mutatora). W ten sposób pytanie nigdy się nie pojawia. Niezmienność staje się trudniejsza w przypadku większych obiektów, ale z drugiej strony jest to, że popycha cię w kierunku podziału na spójne małe obiekty i kompozyty.

Alternatywa dla konstruktorskiej metody kopiowania egaga . Prawdopodobnie masz już POJO, więc po prostu dodaj inną metodę, copy()która zwraca kopię zainicjowanego obiektu.

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
}

Jeśli masz już DummyBeani chcesz kopię:

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

Wynik:

bean1: peet 2
bean2: peet 2

bean1: koos 88
bean2: peet 2

Ale oba działają dobrze, to ostatecznie zależy od ciebie ...

class DB {
  private String dummy;

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

Możesz głęboko kopiować automatycznie za pomocą XStream, z http://x-stream.github.io/ :

XStream to prosta biblioteka do serializacji obiektów do XML iz powrotem.

Dodaj go do swojego projektu (jeśli używasz maven)

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

Następnie

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

Dzięki temu masz kopię bez potrzeby implementowania interfejsu klonowania.

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

  }
}

i w twoim kodzie:

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

Przekaż obiekt, który chcesz skopiować, i uzyskaj żądany obiekt:

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;

    }

Teraz przeanalizuj objDestżądany obiekt.

Happy Coding!

Możesz spróbować zaimplementować Cloneablei użyć tej clone()metody; Jeśli jednak zastosować metodę klonowania ty powinien - według standardowych - nadpisywanie ZAWSZE Object„s public Object clone()metody.

Jeśli możesz dodać adnotację do pliku źródłowego, można użyć procesora adnotacji lub generatora kodu takiego jak ten .

import net.zerobuilder.BeanBuilder

@BeanBuilder
public class DummyBean { 
  // bean stuff
}

Zostanie DummyBeanBuilderswygenerowana klasa , która ma statyczną metodę dummyBeanUpdatertworzenia płytkich kopii, w taki sam sposób, jak robiłbyś to ręcznie.

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

Użyj gsondo powielania obiektu.

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

Przyjmijmy, mam obiektu person.Tak

Person copyPerson = copyObject(person);