Computer Science Review Question

Question

what code produces a reference copy, a shallow copy, and a deep copy?

Answer 1

Objects in Java are passed by their reference.

Shallow copy: copies only the references of the members of the original object. The copy will still point to the same member instances. Therefore manipulating copy could change the state of original object.

Deep copy: duplicates everything by copying over the actual data to a newly allocated segment of memory. The copy will have complete new instance of all members. Therefore manipulating the copy will not affect the original object' state.

The following examples demonstrate the difference between shallow copy and deep copy using an array. Remember array variables are references in Java too.

public class ShallowCopyExample {

private int[] values;

// performs a shallow copy of the numbers array

public ShallowCopyExample(int[] numbers) {

this.values = numbers;

}

public void printValues() {

System.out.println(Arrays.toString(values));

}

}

The values array reference points to memory location of numbers. Therefore manipulating the items through either reference will result in unexpected changes:

public class Test {

public static void main(String[] args) {

int[] numbers = {1, 2, 3, 4, 5};

ShallowCopyExample copier = new ShallowCopyExample(numbers);

copier.printValues(); // prints out [1, 2, 3, 4, 5]

numbers[0] = 9;

copier.printValues(); // prints out [9, 2, 3, 4, 5]

}

}

Note that we did not change the array values inside the ShallowCopyExample class, the change was made through the input array. That can be very confusing.

To avoid this issue we will need to copy the array deeply instead:

public class DeepCopyExample{

private int[] values;

// performs a deep copy of the numbers array

public DeepCopyExample(int[] numbers) {

values = new int[numbers.length];

for (int i = 0; i < numbers.length; i++) {

values[i] = numbers[i];

}

}

public void printValues() {

System.out.println(Arrays.toString(values));

}

}

Let's test to see whether or not we were correct:

public class Test {

public static void main(String []args){

int[] numbers = {1, 2, 3, 4, 5};

DeepCopyExample copier = new DeepCopyExample(numbers);

copier.printValues(); // prints out [1, 2, 3, 4, 5]

numbers[0] = 9;

copier.printValues(); // prints out [1, 2, 3, 4, 5]

}

}

Yes, the code works as expected. The arrays are deeply copies therefore their values will only change if they are manipulated through their only reference.

Answer 2

Objects are passed by reference: data changed by the module affects the original

Shallow copy : the entire object reference is returned; it is NOT a copy BUT THE ORIGINAL;

Deep copy: an entire new block of memory is allocated, and the data copied;

changes made to the copy DO NOT affected the original