¿Cómo se hace una copia profunda de un objeto?

Es un poco difícil implementar una función de copia de objetos profundos. ¿Qué pasos toma para asegurarse de que el objeto original y el clonado no compartan ninguna referencia?

Una forma segura es serializar el objeto y luego deserializarlo. Esto asegura que todo sea una referencia nueva.

Aquí hay un artículo sobre cómo hacer esto de manera eficiente.

Advertencias: es posible que las clases anulen la serialización de modo que no se creen nuevas instancias , por ejemplo, para singletons. Además, por supuesto, esto no funciona si sus clases no son serializables.

Algunas personas han mencionado el uso o la anulación Object.clone(). No lo hagas Object.clone()tiene algunos problemas importantes y se desaconseja su uso en la mayoría de los casos. Consulte el Artículo 11, de " Java efectivo " de Joshua Bloch para obtener una respuesta completa. Creo que puedes usarlo con seguridadObject.clone() en matrices de tipo primitivo, pero aparte de eso, debe ser prudente sobre el uso y la anulación del clon.

Los esquemas que se basan en la serialización (XML o de otro tipo) son poco claros.

No hay una respuesta fácil aquí. Si desea copiar en profundidad un objeto, tendrá que atravesar el gráfico del objeto y copiar cada objeto secundario explícitamente a través del constructor de copia del objeto o un método de fábrica estático que a su vez copia en profundidad el objeto secundario. Los inmutables (p. Ej., StringS) no necesitan copiarse. Por otro lado, debe favorecer la inmutabilidad por este motivo.

Puede realizar una copia profunda con la serialización sin crear archivos.

Su objeto que desea copiar en profundidad deberá hacerlo implement serializable. Si la clase no es final o no se puede modificar, extienda la clase e implemente serializable.

Convierta su clase en una secuencia de bytes:

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

Restaura tu clase desde una secuencia de bytes:

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

Puede hacer un clon profundo basado en serialización usando org.apache.commons.lang3.SerializationUtils.clone(T) Apache Commons Lang, pero tenga cuidado: el rendimiento es abismal.

En general, es una buena práctica escribir sus propios métodos de clonación para cada clase de un objeto en el gráfico de objeto que necesita clonación.

Una forma de implementar la copia profunda es agregar constructores de copia a cada clase asociada. Un constructor de copia toma una instancia de 'this' como argumento único y copia todos los valores de él. Bastante trabajo, pero bastante sencillo y seguro.

EDITAR: tenga en cuenta que no necesita utilizar métodos de acceso para leer los campos. Puede acceder a todos los campos directamente porque la instancia de origen siempre es del mismo tipo que la instancia con el constructor de copia. Obvio pero podría pasarse por alto.

Ejemplo:

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

Editar: tenga en cuenta que cuando usa constructores de copia necesita saber el tipo de tiempo de ejecución del objeto que está copiando. Con el enfoque anterior, no puede copiar fácilmente una lista mixta (es posible que pueda hacerlo con algún código de reflexión).

Puede usar una biblioteca que tenga una API simple y realice una clonación relativamente rápida con reflexión (debería ser más rápida que los métodos de serialización).

Cloner cloner = new Cloner();

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

Apache commons ofrece una forma rápida de clonar profundamente un objeto.

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

XStream es realmente útil en tales casos. Aquí hay un código simple para hacer clonación

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

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

Un enfoque muy fácil y simple es usar Jackson JSON para serializar objetos Java complejos a JSON y leerlo de nuevo.

http://wiki.fasterxml.com/JacksonInFiveMinutes

Para usuarios de Spring Framework . Usando clase org.springframework.util.SerializationUtils:

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

Para objetos complicados y cuando el rendimiento no es significativo, uso una biblioteca json, como gson para serializar el objeto en texto json, luego deserializar el texto para obtener un nuevo objeto.

gson que basado en la reflexión funcionará en la mayoría de los casos, excepto que los transientcampos no se copiarán y los objetos con referencia circular con causa 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);
}

Use XStream ( http://x-stream.github.io/ ). Incluso puede controlar qué propiedades puede ignorar mediante anotaciones o especificando explícitamente el nombre de la propiedad a la clase XStream. Además, no necesita implementar una interfaz clonable.

La copia profunda solo se puede hacer con el consentimiento de cada clase. Si tiene control sobre la jerarquía de clases, puede implementar la interfaz clonable e implementar el método Clone. De lo contrario, es imposible hacer una copia profunda de forma segura porque el objeto también puede compartir recursos que no son de datos (por ejemplo, conexiones de bases de datos). Sin embargo, en general, la copia profunda se considera una mala práctica en el entorno Java y debe evitarse mediante las prácticas de diseño apropiadas.

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

Solía bulldozer para la clonación de objetos de Java y es genial en el que, Kryo biblioteca es otra gran alternativa.

BeanUtils hace un muy buen trabajo de clonación profunda de frijoles.

BeanUtils.cloneBean(obj);

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

Aquí su clase MyPerson y MyAddress deben implementar una interfaz serilazable

Usando Jackson para serializar y deserializar el objeto. Esta implementación no requiere que el objeto implemente la clase Serializable.

  <T> T clone(T object, Class<T> clazzType) throws IOException {

    final ObjectMapper objMapper = new ObjectMapper();
    String jsonStr= objMapper.writeValueAsString(object);

    return objMapper.readValue(jsonStr, clazzType);

  }