Java: solución recomendada para la clonación profunda/copia de una instancia

El libro de Joshua Bloch tiene un capítulo entero titulado "Item 10: Override Clone Juiciously" en el cual él entra en porqué overriding clone para la mayor parte es una mala idea porque la especificación de Java para ella crea muchos problemas.

Él proporciona algunas alternativas:

• Utilice un patrón de fábrica en lugar de un constructor:

       public static Yum newInstance(Yum yum);
  

• Utilice un constructor de copia:

       public Yum(Yum yum);
  

Todas las clases de colección en Java soportan la copia constructor(por ejemplo, new ArrayList (l);)

Desde la versión 2.07 Kryo soporta clonación superficial / profunda :

Kryo kryo = new Kryo();
SomeClass someObject = ...
SomeClass copy1 = kryo.copy(someObject);
SomeClass copy2 = kryo.copyShallow(someObject);

Kryo es rápido, en el y de su página se puede encontrar una lista de las empresas que lo utilizan en la producción.

Utilice XStream ToXML/FromXML en memoria. Extremadamente rápido y ha existido durante mucho tiempo y va fuerte. Los objetos no necesitan ser serializables y no tienes que usar reflexión (aunque XStream sí). XStream puede discernir las variables que apuntan al mismo objeto y no hacer accidentalmente dos copias completas de la instancia. Muchos detalles como ese se han forjado a lo largo de los años. Lo he usado durante varios años y es un ir a. Es tan fácil de usar como puedas imaginar.

new XStream().toXML(myObj)

O

new XStream().fromXML(myXML)

Para clonar,

new XStream().fromXML(new XStream().toXML(myObj))

Más sucintamente:

XStream x = new XStream();
Object myClone = x.fromXML(x.toXML(myObj));

Depende.

Para la velocidad, utilice DIY. Para a prueba de balas, utilice la reflexión.

POR cierto, la serialización no es lo mismo que refl, ya que algunos objetos pueden proporcionar métodos de serialización reemplazados (readObject/writeObject) y pueden tener errores

Recomendaría la forma DIY que, combinada con un buen método hashCode() e equals() debería ser fácil de probar en una prueba unitaria.

Sugiero anular el objeto.clone(), llama a super.clone () primero y luego call ref = ref.clone() en todas las referencias que desee copiar en profundidad. Es más o menos Hágalo usted mismo enfoque, pero necesita un poco menos de codificación.

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

Gson que se basa en la reflexión funciona 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 <ObjectType> ObjectType Copy(ObjectType AnObject, Class<ObjectType> ClassInfo)
{
    Gson gson = new GsonBuilder().create();
    String text = gson.toJson(AnObject);
    ObjectType newObject = gson.fromJson(text, ClassInfo);
    return newObject;
}
public static void main(String[] args)
{
    MyObject anObject ...
    MyObject copyObject = Copy(o, MyObject.class);

}