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

Question

En Java es un poco difícil implementar una función de copia profunda de objetos. ¿Qué pasos debe seguir para garantizar que el objeto original y el clonado no compartan ninguna referencia?

Answer 1

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

Here's an article acerca de cómo hacer esto de manera eficiente.

Advertencias: Es posible que las clases anulen la serialización de modo que las instancias nuevas sean no creadas, p. para singletons También esto, por supuesto, no funciona si tus clases no son serializables.

Answer 2

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

Answer 3

Puede hacer una clonación profunda basada en la serialización usando org.apache.commons.lang3.SerializationUtils.clone(T) en 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 objetos que necesita clonar.

Answer 4

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

Answer 5

XStream es realmente útil en tales casos. Este es un código simple de hacer la clonación

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

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

Answer 6

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

Los esquemas que se basan en la serialización (XML u otros) son kludgy.

No hay una respuesta fácil aquí. Si quiere copiar profundamente un objeto, tendrá que recorrer 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 profundamente el objeto secundario. Los elementos inmutables (por ejemplo, String s) no necesitan copiarse. Como un aparte, debes favorecer la inmutabilidad por este motivo.

Answer 7

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

Answer 8

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

Su objeto que desea copiar profundamente necesitará implement serializable. Si la clase no es definitiva o no se puede modificar, amplíe la clase e implemente serializable.

Convierte tu clase a un flujo de bytes:

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

restaurar su clase a partir de un flujo de bytes:

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

Answer 9

Una forma de implementar copia profunda es añadir constructores de copia a cada uno asociado clase. Un constructor de copia toma una instancia de 'this' como su único argumento y copia todos los valores de la misma. Un poco de 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 copias. Obvio, pero podría ser pasado 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 al utilizar constructores de copia que necesita saber el tipo de ejecución del objeto que va a copiar. Con el enfoque anterior, no puede copiar fácilmente una lista mixta (es posible que pueda hacerlo con un código de reflexión).

Answer 10

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

http://wiki.fasterxml.com/JacksonInFiveMinutes

Answer 11

Puede use a library que tiene una API sencilla, y lleva a cabo la clonación relativamente rápido con la reflexión (debe ser más rápido que los métodos de serialización).

Cloner cloner = new Cloner(); 

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

Answer 12

que utilizan Dozer para la clonación de objetos de Java y es genial en el que, Kryo biblioteca es otra gran alternativa.

Answer 13

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

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

Answer 14

BeanUtils hace un muy buen trabajo habas de clonación profundas.

BeanUtils.cloneBean(obj); 

Answer 15

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 MyPerson y la clase MiDirección deben implementar la interfaz serilazable

Answer 16

Para objetos complicados y cuando el rendimiento no es significativo i utilizar una biblioteca JSON, como gson para serializar el objeto de json text, luego deserializar el texto para obtener un nuevo objeto.

gson que, en función de la reflexión, funcionará en la mayoría de los casos, excepto que los campos transient 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); 

} 

Answer 17

Para Resorte del marco usuarios.El uso de la clase org.springframework.util.SerializationUtils:

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