¿Cómo copio un objeto en Java?

Considere el siguiente código:

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'

Por lo tanto, quiero copiar el dumque dumtwoy el cambio dumsin afectar al dumtwo. Pero el código anterior no está haciendo eso. Cuando cambio algo dum, dumtwotambién está ocurriendo el mismo cambio .

Supongo que, cuando digo dumtwo = dum, Java copia solo la referencia . Entonces, ¿hay alguna forma de crear una copia nueva dumy asignarla dumtwo?

Crea un constructor de copia:

class DummyBean {
  private String dummy;

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

Cada objeto también tiene un método de clonación que se puede usar para copiar el objeto, pero no lo use. Es demasiado fácil crear una clase y hacer un método de clonación incorrecto. Si va a hacer eso, lea al menos lo que Joshua Bloch tiene que decir al respecto en Effective Java .

Básico: Copia de objetos en Java.

Supongamos que un objeto obj1, que contiene dos objetos, contieneObj1 y contenidoObj2 .

copia superficial: la copia
superficial crea una nueva instanceclase de la misma clase y copia todos los campos a la nueva instancia y la devuelve. La clase de objeto proporciona un clonemétodo y proporciona soporte para la copia superficial.

Copia profunda : una copia profunda ocurre cuando un objeto se copia junto con los objetos a los que se refiere . La imagen a continuación se muestra obj1después de que se haya realizado una copia profunda. No solo se obj1ha copiado , sino que también se han copiado los objetos que contiene. Podemos usar Java Object Serializationpara hacer una copia profunda. Desafortunadamente, este enfoque también tiene algunos problemas ( ejemplos detallados ).

Posibles problemas:
clone es difícil de implementar correctamente.
Es mejor usar copias defensivas , constructores de copias (como @egaga reply) o métodos estáticos de fábrica .

1. Si tiene un objeto, sabe que tiene un clone()método público , pero no conoce el tipo de objeto en tiempo de compilación, entonces tiene un problema. Java tiene una interfaz llamada Cloneable. En la práctica, debemos implementar esta interfaz si queremos hacer un objeto Cloneable. Object.cloneestá protegido , por lo que debemos anularlo con un método público para que sea accesible.
   
2. Otro problema surge cuando intentamos copiar en profundidad un objeto complejo . Suponga que el clone()método de todas las variables de objeto miembro también hace una copia profunda, esto es demasiado arriesgado de suponer. Debe controlar el código en todas las clases.
   

Por ejemplo, org.apache.commons.lang.SerializationUtils tendrá un método para clonar en profundidad usando la serialización ( Fuente ). Si necesitamos clonar Bean, entonces hay un par de métodos de utilidad en org.apache.commons.beanutils ( Fuente ).

• cloneBean clonará un bean en función de los captadores y establecedores de propiedades disponibles, incluso si la clase de bean no implementa Cloneable.
• copyProperties copiará los valores de propiedad del bean de origen al bean de destino para todos los casos en que los nombres de propiedad sean los mismos.

En el paquete import org.apache.commons.lang.SerializationUtils;hay un método:

SerializationUtils.clone(Object);

Ejemplo:

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

Solo sigue lo siguiente:

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

y donde quiera obtener otro objeto, simplemente realice la clonación. p.ej:

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

¿Por qué no hay una respuesta para usar Reflection API?

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

Es muy simple

EDITAR: Incluir objeto hijo a través de recursión

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

Utilizo la biblioteca JSON de Google para serializarla y luego crear una nueva instancia del objeto serializado. Hace una copia profunda con algunas restricciones:

• no puede haber referencias recursivas

• no copiará matrices de tipos dispares

• las matrices y las listas deben escribirse o no encontrará la clase para instanciar

• es posible que necesite encapsular cadenas en una clase que declare

También uso esta clase para guardar las preferencias del usuario, las ventanas y otras cosas que se deben volver a cargar en tiempo de ejecución. Es muy fácil de usar y efectivo.

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í, solo estás haciendo referencia al objeto. Puede clonar el objeto si implementaCloneable .

Mira este artículo wiki sobre cómo copiar objetos.

Consulte aquí: copia de objetos

Agrega Cloneabley debajo del código a tu clase

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

Utilizar este clonedObject = (YourClass) yourClassObject.clone();

Si. Necesita copiar en profundidad su objeto.

Esto tambien funciona. Asumiendo modelo

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

Primero agregue compile 'com.google.code.gson:gson:2.8.1'a su aplicación> gradle & sync. Entonces

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

Puede excluir el uso de un campo utilizando la transientpalabra clave después del modificador de acceso.

Nota: esta es una mala práctica. Tampoco recomiendo usar Cloneableo JavaSerializationes lento y roto. Escriba el constructor de copias para obtener el mejor rendimiento ref .

Algo como

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

Estadísticas de prueba de iteración 90000: la
línea UserAccount clone = gson.fromJson(gson.toJson(aO), UserAccount.class);tarda 808 ms

La línea UserAccount clone = new UserAccount(aO);tarda menos de 1 ms

Conclusión: usa gson si tu jefe está loco y prefieres la velocidad. Use el segundo constructor de copias si prefiere la calidad.

También puede usar el complemento generador de código de constructor de copia en Android Studio.

Aquí hay una explicación decente de clone()si terminas necesitándolo ...

Aquí: clonar (método Java)

Use una utilidad de clonación profunda:

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

Esto copiará en profundidad cualquier objeto Java, échale un vistazo en https://github.com/kostaskougios/cloning

Deep Cloning es su respuesta, que requiere implementar la Cloneableinterfaz y anular el clone()método.

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 llamarás así DummyBean dumtwo = dum.clone();

Para hacer eso tienes que clonar el objeto de alguna manera. Aunque Java tiene un mecanismo de clonación, no lo use si no es necesario. Cree un método de copia que haga la copia por usted y luego haga:

dumtwo = dum.copy();

Aquí hay más consejos sobre diferentes técnicas para realizar una copia.

Además de copiar explícitamente, otro enfoque es hacer que el objeto sea inmutable (ningún setmétodo mutante u otro). De esta manera, la pregunta nunca surge. La inmutabilidad se vuelve más difícil con objetos más grandes, pero ese otro lado de eso es que te empuja en la dirección de dividirte en pequeños objetos coherentes y compuestos.

Alternativa al método de copia del constructor de egaga . Probablemente ya tenga un POJO, así que simplemente agregue otro método copy()que devuelva una copia del objeto inicializado.

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 ya tiene una DummyBeany quiere 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());

Salida:

bean1: peet 2
bean2: peet 2

bean1: koos 88
bean2: peet 2

Pero ambos funcionan bien, en última instancia depende de usted ...

class DB {
  private String dummy;

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

Puede copiar en profundidad automáticamente con XStream, desde http://x-stream.github.io/ :

XStream es una biblioteca simple para serializar objetos a XML y viceversa.

Agréguelo a su proyecto (si usa maven)

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

Entonces

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

Con esto, tiene una copia sin la necesidad de implementar ninguna interfaz de clonación.

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

  }
}

y en tu código:

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

Pase el objeto que desea copiar y obtenga el objeto que desea:

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;

    }

Ahora analiza el objDest objeto deseado.

¡Feliz codificación!

Puede intentar implementar Cloneabley usar el clone()método; sin embargo, si usa el método de clonación, debería, por norma, SIEMPRE anular Objectel public Object clone()método.

Si puede agregar una anotación al archivo fuente, se puede usar un procesador de anotación o un generador de código como este .

import net.zerobuilder.BeanBuilder

@BeanBuilder
public class DummyBean { 
  // bean stuff
}

Se DummyBeanBuildersgenerará una clase , que tiene un método estático dummyBeanUpdaterpara crear copias superficiales, de la misma manera que lo haría manualmente.

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

Úselo gsonpara duplicar un objeto.

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

Supongamos que tengo un objeto person.

Person copyPerson = copyObject(person);