Shallow Copy vs Deep Copy en Java: Diferencias y Métodos de Implementación ========================================================================== 1\. Introducción ---------------- Cuando queremos copiar un objeto en Java, debemos considerar dos posibilidades: **una copia superficial (shallow copy) y una copia profunda (deep copy)**. En el enfoque de la copia superficial, solo copiamos los valores de los campos, por lo que la copia puede depender del objeto original. Por otro lado, en el enfoque de la copia profunda, nos aseguramos de que todos los objetos en el árbol sean copiados de forma completa, de manera que la copia no dependa de ningún objeto existente que pueda cambiar en el futuro. En este tutorial, compararemos estos dos enfoques y aprenderemos cuatro métodos para implementar la copia profunda. 2\. Configuración de Maven -------------------------- Para probar diferentes maneras de realizar una copia profunda, utilizaremos tres dependencias de Maven: **Gson**, **Jackson** y **Apache Commons Lang**. Vamos a añadir estas dependencias a nuestro archivo `pom.xml`: com.google.code.gson gson 2.10.1 org.apache.commons commons-lang3 3.14.0 com.fasterxml.jackson.core jackson-databind 2.17.2 Las últimas versiones de [Gson](https://mvnrepository.com/artifact/com.google.code.gson/gson), [Jackson](https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind) y [Apache Commons Lang](https://mvnrepository.com/artifact/commons-lang/commons-lang) se pueden encontrar en Maven Central. 3\. Modelo ---------- Para comparar diferentes métodos de copia de objetos en Java, necesitaremos dos clases con las que trabajar: class Address { private String street; private String city; private String country; // Constructores estándar, getters y setters } class User { private String firstName; private String lastName; private Address address; // Constructores estándar, getters y setters } 4\. Copia Superficial --------------------- Una copia superficial es aquella en la que **solo copiamos los valores de los campos** de un objeto a otro. @Test public void whenShallowCopying_thenObjectsShouldNotBeSame() { Address address = new Address("Downing St 10", "London", "England"); User pm = new User("Prime", "Minister", address); User shallowCopy = new User(pm.getFirstName(), pm.getLastName(), pm.getAddress()); assertThat(shallowCopy).isNotSameAs(pm); } En este caso, `pm != shallowCopy`, lo que significa que **son objetos diferentes; sin embargo, el problema es que cuando cambiamos alguna de las propiedades del objeto original `address`, esto también afectará a la dirección de `shallowCopy`**. No nos preocuparíamos por esto si `Address` fuera inmutable, pero no lo es: @Test public void whenModifyingOriginalObject_ThenCopyShouldChange() { Address address = new Address("Downing St 10", "London", "England"); User pm = new User("Prime", "Minister", address); User shallowCopy = new User(pm.getFirstName(), pm.getLastName(), pm.getAddress()); address.setCountry("Great Britain"); assertThat(shallowCopy.getAddress().getCountry()).isEqualTo(pm.getAddress().getCountry()); } 5\. Copia Profunda ------------------ Una copia profunda es una alternativa que soluciona este problema. Su ventaja es que **cada objeto mutable en el grafo de objetos se copia de forma recursiva**. Debido a que la copia no depende de ningún objeto mutable que se haya creado anteriormente, no se modificará accidentalmente como vimos con la copia superficial. En las secciones siguientes, discutiremos varias implementaciones de copia profunda y demostraremos esta ventaja. ### 5.1. Constructor de Copia La primera implementación que examinaremos se basa en constructores de copia: public Address(Address that) { this(that.getStreet(), that.getCity(), that.getCountry()); } public User(User that) { this(that.getFirstName(), that.getLastName(), new Address(that.getAddress())); } En la implementación anterior de la copia profunda, no hemos creado nuevas instancias de `String` en nuestro constructor de copia porque `String` es una clase inmutable. @Test public void whenModifyingOriginalObject_thenCopyShouldNotChange() { Address address = new Address("Downing St 10", "London", "England"); User pm = new User("Prime", "Minister", address); User deepCopy = new User(pm); address.setCountry("Great Britain"); assertNotEquals(pm.getAddress().getCountry(), deepCopy.getAddress().getCountry()); } ### 5.2. Interfaz Cloneable La segunda implementación se basa en el método `clone` heredado de `Object`. Este es protegido, pero necesitamos sobreescribirlo como `public`. También agregaremos una interfaz marcador, `Cloneable`, a las clases para indicar que las clases son realmente clonables. Veamos cómo añadir el método `clone()` a la clase `Address`: @Override public Object clone() { try { return (Address) super.clone(); } catch (CloneNotSupportedException e) { return new Address(this.street, this.getCity(), this.getCountry()); } } Ahora, implementemos `clone()` para la clase `User`: @Override public Object clone() { User user = null; try { user = (User) super.clone(); } catch (CloneNotSupportedException e) { user = new User(this.getFirstName(), this.getLastName(), this.getAddress()); } user.address = (Address) this.address.clone(); return user; } _Nota importante:_ el llamado a `super.clone()` devuelve una copia superficial del objeto, pero configuramos copias profundas de los campos mutables manualmente, por lo que el resultado es correcto: @Test public void whenModifyingOriginalObject_thenCloneCopyShouldNotChange() { Address address = new Address("Downing St 10", "London", "England"); User pm = new User("Prime", "Minister", address); User deepCopy = (User) pm.clone(); address.setCountry("Great Britain"); assertThat(deepCopy.getAddress().getCountry()).isNotEqualTo(pm.getAddress().getCountry()); } 6\. Bibliotecas Externas ------------------------ Los ejemplos anteriores parecen sencillos, pero a veces no funcionan como solución **cuando no podemos agregar un constructor adicional o sobreescribir el método clone**. Esto puede suceder si no poseemos el código, o si el grafo de objetos es tan complicado que no terminaríamos nuestro proyecto a tiempo si nos enfocáramos en escribir constructores adicionales o en implementar el método `clone` en todas las clases del grafo de objetos. Entonces, ¿qué podemos hacer en ese caso? En este caso, podemos usar una biblioteca externa. Para lograr una copia profunda, **podemos serializar un objeto y luego deserializarlo a un nuevo objeto**. Veamos algunos ejemplos. ### 6.1. Apache Commons Lang Apache Commons Lang tiene `SerializationUtils#clone`, que realiza una copia profunda cuando todas las clases en el grafo de objetos implementan la interfaz `Serializable`. _Nota:_ Si el método encuentra una clase que no es serializable, fallará y lanzará una `SerializationException`: @Test public void whenModifyingOriginalObject_thenCommonsCloneShouldNotChange() { Address address = new Address("Downing St 10", "London", "England"); User pm = new User("Prime", "Minister", address); User deepCopy = (User) SerializationUtils.clone(pm); address.setCountry("Great Britain"); assertThat(deepCopy.getAddress().getCountry()).isNotEqualTo(pm.getAddress().getCountry()); } ### 6.2. Serialización JSON con Gson La otra manera de serializar es mediante la serialización JSON. Gson es una biblioteca que se utiliza para convertir objetos en JSON y viceversa. A diferencia de Apache Commons Lang, **GSON no necesita la interfaz `Serializable` para realizar las conversiones**. Adicionalmente, los campos `transient` no son permitidos con Gson. Veamos un rápido ejemplo: @Test public void whenModifyingOriginalObject_thenGsonCloneShouldNotChange() { Address address = new Address("Downing St 10", "London", "England"); User pm = new User("Prime", "Minister", address); Gson gson = new Gson(); User deepCopy = gson.fromJson(gson.toJson(pm), User.class); address.setCountry("Great Britain"); assertThat(deepCopy.getAddress().getCountry()).isNotEqualTo(pm.getAddress().getCountry()); } ### 6.3. Serialización JSON con Jackson Jackson es otra biblioteca que soporta la serialización JSON. Esta implementación será muy similar a la que usa Gson, pero **necesitamos agregar un constructor por defecto a nuestras clases**. Veamos un ejemplo: @Test public void whenModifyingOriginalObject_thenJacksonCopyShouldNotChange() throws IOException { Address address = new Address("Downing St 10", "London", "England"); User pm = new User("Prime", "Minister", address); ObjectMapper objectMapper = new ObjectMapper(); User deepCopy = objectMapper.readValue(objectMapper.writeValueAsString(pm), User.class); address.setCountry("Great Britain"); assertThat(deepCopy.getAddress().getCountry()).isNotEqualTo(pm.getAddress().getCountry()); } 7\. Conclusión -------------- ¿Qué implementación deberíamos utilizar al realizar una copia profunda? La decisión final dependerá a menudo de las clases que copiaremos y de si poseemos las clases en el grafo de objetos. La copia profunda es fundamental cuando necesitamos asegurarnos de que las modificaciones en el objeto original no afecten el objeto copiado. Ya sea mediante constructores de copia, el uso de la interfaz `Cloneable` o bibliotecas externas como Gson y Jackson, entender cómo funciona la copia profunda puede ahorrarle a un programador una gran cantidad de problemas y bugs. Si trabajas con copias de objetos en Java, recuerda evaluar cada situación por separado para determinar qué enfoque es mejor para tus necesidades.

Diferencias entre Copia Superficial y Profunda en Java