does creating shallow copy means sharing same object by reference variables?

[Ganish Patil]

Here is my code where I created shallow copy of an object using clone method. I just want to know does cloning creates new another object or just both reference variables here newKeywordObj1 and shallowCopyObj share the same object? because changing value of 0th index of arrayValue array also changing value of shallowCopyObj object when printed. if those two reference variables newKeywordObj1 and shallowCopyObj share the same object then why both objects have different hash code? If I'm not wrong each object have a unique hash code.

package shallowndeepcopy;

public class ShallowDeepCopyDemo implements Cloneable {

	int value;
	int arrayValue[];
	String name;

	public ShallowDeepCopyDemo(int value, int arrayValues[], String name) {
		this.value = value;
		this.arrayValue = arrayValues;
		this.name = name;
	}

	public void printValue() {

		System.out.println("Object hashCode: " + this.hashCode() + " Value:" + this.value + " Name: " + this.name);
		for (int i = 0; i < arrayValue.length; i++) {
			System.out.println(arrayValue[i]);
		}
	}

	public static void main(String[] args) {
		// Below array for object created by using new keyword

		int arrayValue[];
		arrayValue = new int[5];
		for (int i = 0; i < arrayValue.length; i++) {
			arrayValue[i] = i + 1;
		}

		// Below array for object created by using clone

		int arrayValueCopy[];
		arrayValueCopy = new int[5];

		for (int i = 0; i < arrayValueCopy.length; i++) {
			arrayValueCopy[i] = i + 10;
		}

		ShallowDeepCopyDemo newKeywordObj1 = new ShallowDeepCopyDemo(10, arrayValue, "Java");
		System.out.println("************Object created by new keyword************");
		newKeywordObj1.printValue();

		ShallowDeepCopyDemo shallowCopyObj = null;
		// Shallow Copy by using clone
		try {
			shallowCopyObj = (ShallowDeepCopyDemo) newKeywordObj1.clone();
			System.out.println("************Object created by clone method************");
			shallowCopyObj.printValue();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}

		arrayValue[0] = 100;
		System.out.println("************After changing values of field of Object created by new keyword************");
		System.out.println("Output by newkeyword object");
		newKeywordObj1.printValue();
		System.out.println("Output by cloned object");
		shallowCopyObj.printValue();

	}

}

Output:************Object created by new keyword************
Object hashCode: 1284693 Value:10 Name: Java
1
2
3
4
5
************Object created by clone method************
Object hashCode: 31168322 Value:10 Name: Java
1
2
3
4
5
************After changing values of field of Object created by new keyword************
Output by newkeyword object
Object hashCode: 1284693 Value:10 Name: Java
100
2
3
4
5
Output by cloned object
Object hashCode: 31168322 Value:10 Name: Java
100
2
3
4
5

[Ganish Patil]

Please see image to know what I want to know

[Winston Gutkowski]

Ganish Patil wrote:I just want to know does cloning creates new another object or just both reference variables here newKeywordObj1 and shallowCopyObj share the same object?

Your question is a little confusing, but I'll try to answer. But first you need to understand the distinction between an object and a reference.

1. Ignoring cached values, the ONLY way to create an object in Java is with the new keyword. Now it's possible that a class may only provide "factory" methods, so as a client, you may never use one yourself; but the factory method itself will contain a 'new' call somewhere.

2. Once an object is created, it's reference can be assigned to any number of variables. So in the following case:
  String s1 = new String("Hello World");
  String s2 = s1;
both s1 and s2 will contain a reference to the same String object.

3. All arrays In Java are objects, so similarly:
  int[] a1 = new int[] (1, 2, 3};
  int[] a2 = a1;
both a1 and a2 will contain a reference to the same array.

4. All arrays In Java are mutable. That means that you can change the contents of an element any time you want to. So, given the code in #3 above:
  a1[0] = 100;
  System.out.println(a2[0]);
will result in
  100
because a1[0] and a2[0] both refer to element 0 in the same array

So, getting back to the difference between "shallow" and "deep" copying: a "shallow" copy usually means that only references have been copied; NOT the objects themselves.

However, when it comes to cloning - and specifically cloning that uses the Cloneable interface (which is based on Object.clone()) correctly, the result is usually a "deep" copy - that is to say, every member object in the object being cloned will itself be copied, resulting in two objects with the same contents.

Unfortunately, arrays are an exception to that rule, and when Java clones an array, it creates a new array with each element copied - and if that element contains a reference, it simply copies the reference, NOT the object that it refers to.
Now generally, this is all you need, and in the above case - where each element is an int - it's exactly what you want, so:
  int[] a1 = new int[] (1, 2, 3};
  int[] a2 = a1.clone();
  a1[0] = 100;
  System.out.println(a2[0]);
will result in
  1

But if an element is an object - and specifically, a mutable object - then you can still get "odd" results. For example:

AtomicInteger[] a1 = new AtomicInteger[] {
  new AtomicInteger(1),
  new AtomicInteger(2),
  new AtomicInteger(3)
};
AtomicInteger[] a2 = a1.clone();

a1[0].set(100); // sets a1[0] to 100
System.out.println(a2[0].get());

will result in
  100
because even though a1 and a2 are now different arrays, their 0 elements contain the same reference, so when you use it, you're updating the same object.

Hope I haven't muddied the waters too much for you, but that's a 'potted' version of the difference between "shallow" and "deep" copying, and hopefully explains why you're seeing what you're seeing.

Winston

[Ganish Patil]

Really splendid explanation,

Winston Gutkowski wrote: the ONLY way to create an object in Java is with the new keyword.

First time came to know, thought Class.forName() and clone methods etc. create an object but now got to know about factory methods. Yes I got the concept of shallow copy and deep copy.

As you gave example above I wrote a program.

package cloneexample;

public class CloneDemo {

	public static void main(String[] args) {

		int number[] = new int[] { 1, 2, 3 };
		int numbercopy[] = number.clone();

		numbercopy[1] = 11;

		System.out.println("Original");
		for (int no : number) {
			System.out.println(no);
		}
		System.out.println("Cloned");
		for (int no : numbercopy) {
			System.out.println(no);
		}

	}

}

Output:
Original
1
2
3
Cloned
1
11
3
Here in above program got the correct output
But beneath in my new program
Wrong answer I got: When I change the value of 0th element of int[] marks of object myClsDeepCopyObj1 to 35 it is also changing the value of 0th element of int[] marks of object myClsNewKeywordObj1 which actually should be 80.
Correct answer I got of: When I changed the value of age variable of object myClsDeepCopyObj1 to 25 then only it's value is changed not myClsNewKeywordObj1. I also got about AtomicInteger idNumber as it is object reference so both points to same reference when changed both prints same value 201.

package deepcopy;

import java.util.concurrent.atomic.AtomicInteger;

class MyClass implements Cloneable{
	
	private int age;
	private String name;
	private int marks[];
	private AtomicInteger idNumber[];
	
	public AtomicInteger[] getIdNumber() {
		return idNumber;
	}
	public void setIdNumber(AtomicInteger idNumber[]) {
		this.idNumber = idNumber;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int[] getMarks() {
		return marks;
	}
	public void setMarks(int[] marks) {
		this.marks = marks;
	}
	
	public void displayInfo(){
		System.out.println("Name: "+this.name);
		System.out.println("Age: "+ this.age);
		System.out.println("Id Numbers: ");
		
		for(AtomicInteger idNo: this.idNumber){
			System.out.println(idNo);
		}
		
		System.out.println("marks");
		for(int mark:this.marks){
			System.out.println(mark);
		}
	}
	
	public Object clone() throws CloneNotSupportedException{
			return super.clone();
	}
}


public class DeepCopyDemo {

	public static void main(String[] args) throws CloneNotSupportedException {
		
		int marksArray[] = new int[]{80,76,90};
		
		AtomicInteger idNumbers[] = new AtomicInteger[]{
				new AtomicInteger(1),
				new AtomicInteger(2),
				new AtomicInteger(3)
		};
		
		MyClass myClsNewKeywordObj1 = new MyClass();
                
       // Setting values to the fields of object myClsNewKeywordObj1    
		myClsNewKeywordObj1.setAge(29);
		myClsNewKeywordObj1.setMarks(marksArray);
		myClsNewKeywordObj1.setName("Ganesh");
		myClsNewKeywordObj1.setIdNumber(idNumbers);
		
      // Deep copy using clone method		
		MyClass myClsDeepCopyObj1 = (MyClass)myClsNewKeywordObj1.clone();
		
		System.out.println("Information of object created by new keyword");
		myClsNewKeywordObj1.displayInfo();
		
		System.out.println("Information of object created by clone method");
		myClsDeepCopyObj1.displayInfo();
		
       // Changed value of age from 29 to 25, marks[0] from 80 to 35 and idNumber[0] from 1 to 201 of myClsDeepCopyObj1 object.		
		System.out.println("After changing value of fields age, marks[0], idNumber[0] of object created by clone method");

		myClsDeepCopyObj1.setAge(25);
		
		AtomicInteger tempIdNumber[] = myClsDeepCopyObj1.getIdNumber();
		tempIdNumber[0].set(201);
		myClsDeepCopyObj1.setIdNumber(tempIdNumber);
		
		int tempMarks[] = myClsDeepCopyObj1.getMarks();
		tempMarks[0] = 35;
		myClsDeepCopyObj1.setMarks(tempMarks);
		
		
		System.out.println("Information of object created by new keyword");
		myClsNewKeywordObj1.displayInfo();
		
		System.out.println("Information of object created by clone method");
		myClsDeepCopyObj1.displayInfo();
	}
}

[Winston Gutkowski]

Ganish Patil wrote:But beneath in my new program
Wrong answer I got: When I change the value of 0th element of int[] marks of object myClsDeepCopyObj1 to 35 it is also changing the value of 0th element of int[] marks of object myClsNewKeywordObj1 which actually should be 80.
Correct answer I got of: When I changed the value of age variable of object myClsDeepCopyObj1 to 25 then only it's value is changed not myClsNewKeywordObj1. I also got about AtomicInteger idNumber as it is object reference so both points to same reference when changed both prints same value 201.

And I suspect that's down to what I said above: When Java clones arrays, it creates a "shallow" copy, which is fine for primitives, and things like String[], but NOT for arrays of mutable objects.

If you want a truly deep copy, then you need to amend your clone() method, viz:

public MyClass clone() throws CloneNotSupportedException {
   MyClass clone = (MyClass) super.clone();
   int length = this.idNumber.length;

   clone.idNumber = new AtomicInteger[length];

   for (int i = 0; i < length; i++) {
      clone.idNumber[i] = new AtomicInteger( this.idNumber[i].get() );
   }

   return clone;
}

Do you see the difference? Now you're forcefully copying each element of your idNumber array to a new object with the same value.

Note: I should probably have added that Object.clone() can handle any member that is itself Cloneable (including arrays) but, if you want a truly "deep" clone, you have to add code like the above to explicitly copy any member object that is (a) mutable, and (b) doesn't implement the Cloneable interface.

Not easy is it?

Winston

[Ganish Patil]

Winston Gutkowski wrote: When Java clones arrays, it creates a "shallow" copy, which is fine for primitives, and things like String[]

but this code is doing deep copy I think am I correct ?

package cloneexample;
 public class CloneDemo {
 
    public static void main(String[] args) {
 
        int number[] = new int[] { 1, 2, 3 };
        int numbercopy[] = number.clone();
 
        numbercopy[1] = 11;
 
        System.out.println("Original");
        for (int no : number) {
            System.out.println(no);
        }
        System.out.println("Cloned");
        for (int no : numbercopy) {
            System.out.println(no);
        }
 
    }
 
}

Output:
Original
1
2
3
Cloned
1
11
3

because when I changed value of element at 1th location of int numbercopy[] doesn't change value at index 1 of int number[]. so they have different references means this clone copied complete object not reference, hope I'm on right path If this is doing deep copy then why this not doing deep copy of array of int in my main program on line no 96, below is code

int tempMarks[] = myClsDeepCopyObj1.getMarks();
        tempMarks[0] = 35;
        myClsDeepCopyObj1.setMarks(tempMarks);

It does deep copy with int age variable on line no 90, here is code

myClsDeepCopyObj1.setAge(25);

yes it's not that easy as I thought

[Winston Gutkowski]

Ganish Patil wrote:

Winston Gutkowski wrote: When Java clones arrays, it creates a "shallow" copy, which is fine for primitives, and things like String[]

but this code is doing deep copy I think am I correct ?

No, The reason it "works" is that ints are primitives, so when they are copied, you get a whole new value that is a copy of the original. And you'll get that whether your clone is "shallow" or "deep".

Strings are NOT primitives, they are objects, so they have a reference. However, they are also immutable - ie, you can't change them.

What you can do though is "simulate" a change by replacing a reference with a completely new String , viz:
  name = name.toUpperCase();
which replaces the reference in 'name' with one for a new String object containing only uppercase letters.

So if you clone an array of Strings, it will copy the references (a "shallow" copy); but this is normally sufficient because, since you cant "change" a String without replacing its reference, the elements in the two arrays will now point to two different String objects if you change one of them.

It's only when an object is mutable that you get problems - which is why you should generally avoid them if you can.
An AtomicInteger can be changed without affecting its reference, so if you want to truly "clone" an AtomicInteger[] array, you can't rely on Java to do it properly.

HIH

Winston

[Ganish Patil]

Last doubt.

No, The reason it "works" is that ints are primitives, so when they are copied, you get a whole new value that is a copy of the original. And you'll get that whether your clone is "shallow" or "deep".

then array of int elements i.e. primitives in my main program is not showing different outputs as below code shows

package cloneexample;
 public class CloneDemo {
  
    public static void main(String[] args) {
  
        int number[] = new int[] { 1, 2, 3 };
        int numbercopy[] = number.clone();
  
        numbercopy[1] = 11;
  
        System.out.println("Original");
        for (int no : number) {
            System.out.println(no);
        }
        System.out.println("Cloned");
        for (int no : numbercopy) {
            System.out.println(no);
        }
  
    }
  
}

Output:
Original
1
2
3
Cloned
1
11
3

I wrote another program so will be easy to understand what I'm not getting, here below is program like same above code just wrote in separate class. but when changed value of 1th index of array the output of both object's myNumbers[1] is same i.e. 300. Why this one is not different like myNumbers[1] of newKeywordclnObj1 should be 2 and only myNumbers[1] of deepCpyObj1 should be 300 as we got in above code?

package cloneexample;

class Clone implements Cloneable {
	int myNumbers[];

	public int[] getMyNumbers() {
		return myNumbers;
	}

	public void setMyNumbers(int[] myNumbers) {
		this.myNumbers = myNumbers;
	}

	public void printInfo() {
		for (int no : this.myNumbers) {
			System.out.println(no);
		}
	}

	public Clone clone() throws CloneNotSupportedException {
		// Although I wrote separate code still not working
		Clone myClone = (Clone) super.clone();
		int length = this.getMyNumbers().length;

		int tempMyNumbers[] = myClone.getMyNumbers();
		int orgnlMyNumbers[] = this.getMyNumbers();

		for (int i = 0; i < length; i++) {
			tempMyNumbers[i] = orgnlMyNumbers[i];
		}

		return myClone;
	}
}

public class CloneExample {

	public static void main(String[] args) throws CloneNotSupportedException {

		int myNumbers[] = new int[] { 1, 2, 3 };

		Clone newKeywordclnObj1 = new Clone();
		newKeywordclnObj1.setMyNumbers(myNumbers);
		System.out.println("Output by newKeywordclnObj1 object");
		newKeywordclnObj1.printInfo();

		Clone deepCpyObj1 = newKeywordclnObj1.clone();
		System.out.println("Output by deepCpyObj1 object");
		deepCpyObj1.printInfo();

		// Here I changed value of int array i.e. myNumbers of deepCpyObj1
		// object
		int tempMyNumbers[] = deepCpyObj1.getMyNumbers();
		tempMyNumbers[1] = 300;
		deepCpyObj1.setMyNumbers(tempMyNumbers);

		System.out.println("Output After changing values");
		System.out.println("Output by newKeywordclnObj1 object");
		//Below both object print 1th index of int array myNumbers[1] as 300 why?
		newKeywordclnObj1.printInfo();
		System.out.println("Output by deepCpyObj1 object");
		deepCpyObj1.printInfo();

	}

}

Output:
Output by newKeywordclnObj1 object
1
2
3
Output by deepCpyObj1 object
1
2
3
Output After changing values
Output by newKeywordclnObj1 object
1
300 // This actually should 2
3
Output by deepCpyObj1 object
1
300 // This is correct
3

[Winston Gutkowski]

Ganish Patil wrote:Last doubt....I wrote another program so will be easy to understand what I'm not getting,..Why this one is not different like myNumbers[1] of newKeywordclnObj1 should be 2 and only myNumbers[1] of deepCpyObj1 should be 300 as we got in above code?[/b]

Because it looks like Object.clone() doesn't clone member objects - even if they're Cloneable - it simply copies their references (see the link above for the full docs).
Sorry if I misled you there, but it's ages since I actually wrote a clone() method.

Therefore your two arrays are NOT clones and you'll have to do it yourself; and the simplest way to do that for a primitive or immutable object array is:

public Clone clone() throws CloneNotSupportedException {
   Clone myClone = (Clone) super.clone();
   myClone.myNumbers = this.myNumbers.clone();

   return myClone;
}

but for an array of mutable objects, you have to explicitly copy each element object and assign its reference to your new array, viz - if myNumbers is an AtomicInteger[]:

public Clone clone() throws CloneNotSupportedException {
   Clone myClone = (Clone) super.clone();
    // Clone the array (Note: this produces a SHALLOW copy).
   myClone.myNumbers = this.myNumbers.clone();
   // NOW clone its "contents" - ie, clone each object.
   for (int i = 0; i < myClone.myNumbers.length; i++) {
      int value = myClone.myNumbers[i].get();
      myClone.myNumbers[i] = new AtomicInteger(value);
   }
   return myClone;
}

Hope it makes sense.

Note: this is one case where you can't use a "getter". You must assign the value directly to the member field.

HIH. And sorry for steering you wrong before.

Winston

[Ganish Patil]

Pardon me for late reply as I'm so lazy no consistency in study, it is this forum makes me study

Winston Gutkowski wrote:Note: this is one case where you can't use a "getter". You must assign the value directly to the member field.

yes got that now, both works very well as I expected. Thank you so much. Now I'm clear with these two concepts.