When we copy a primitive value from one variable to another, a duplicate value is created. For example, the following statements
int data = 2; int copyOfData = data;
result in two variables that each contain the integer 2. This is illustrated below.
What happens when variables represent objects? Well, such a variable will contains a reference to the object. For example, the statements
String bug = "spider"; String insect = bug;
create two variables that contain the same reference to the string
"spider". In fact,
insect are alisases, as pictured here:
An alias does not reference a copy of an object. So, what happens when we duplicate an object?
In the following illustration, the variable
anObject references an object, and the variable
anObjectCopy references a duplicate of the object.
The original object has a data field that references a different object. The data field and its reference are duplicated in the object’s copy. This duplicate reference is an alias; thus, the original object and its copy both reference the same piece of data. For this reason, the copy is known as a shallow copy.
Note: An object’s shallow copy
A duplicate of an object that shares some or all of its component objects with the original object is known as a shallow copy.
We again consider the object referenced by the variable
anObject and its copy that the variable
anObjectCopy references. However, this time, rather than duplicating the reference in the object’s data field, we duplicate the object the data field references. The following illustration depicts these objects. We now have a deep copy of the original object.
Note: An object’s deep copy
An exact duplicate of an object that also duplicates all of its component objects is known as a deep copy. This duplicate is completely distinct from the original object. A clone in Java is the same as a deep copy. When you copy an object that can be modified, perhaps by a set method, the copy should be a deep copy.
In Java, an array is an object. Arrays can contain primitive values or references to objects. So, what happens when we make a copy of an array?
When we duplicate an array of primitive values, such as integers, we get two arrays that each contain the same primitive values, as shown here:
An array of objects contains only references to the objects, not the objects themselves. Thus, copying such an array copies the references.
If we duplicated an array of strings, for example, we would get two distinct arrays, as shown below:
The references, but not the strings, are copied from one array to the other. Thus, each array would contain its own references to the strings, but there would only be one set of strings. Thus, the copy of the array is a shallow copy.
Note: Since any string, once created, cannot be altered, sharing it causes no problems. Thus, a shallow copy of an array of strings is perfectly acceptable.
If we were to create duplicates of both the array and the strings, the original array and the duplicate array would each reference their own set of strings. This duplicate array would be a deep copy or a clone.