Is clone() in java shallow copy?

Question

Is clone() in java a shallow copy?

Eventually this gets to the clone() method of Object (the uppermost class), which creates a new instance of the same class as the object and copies all the fields to the new instance (a "shallow copy").

I read this from wikipedia.

I don't understand why it is a shallow copy. clone() will create a new instance with all fields. Is this just a deep copy? confused. Need some explanation for me.

Among many other duplicates of this, http://stackoverflow.com/questions/1175620/in-java-what-is-a-shallow-copy — mindas, Mar 11 '11 at 23:01

score 20 · Accepted Answer · answered Mar 11 '11 at 23:00

20

The default Object.clone() is indeed a shallow copy. However, it's designed to throw a CloneNotSupportedException unless your object implements Cloneable.

And when you implement Cloneable, you should override clone() to make it do a deep copy, by calling clone() on all fields that are themselves cloneable.

answered Mar 11 '11 at 23:00

C. K. Young

219,335
46
382
435

7

making clone deep or shallow is not a "should" or "should not" type of thing, it entirely depends on the intended usage. – jtahlborn Mar 11 '11 at 23:02
3

@jtahlborn: It's indeed a "should" thing, in that others who call your `clone` will be expecting the behaviour as described. Of course, there are exceptions, such as for generic containers (@jt's answer). But in general, that's the expectation. – C. K. Young Mar 11 '11 at 23:04
2

actually, considering all the containers use shallow clone, why would you claim that deep is the expectation? (containers being the only mutable classes in the jdk which are cloneable, that i can think of). – jtahlborn Mar 12 '11 at 01:14
2

for deep copy, you can serialize the object (in memory) and deserialize to a new object. it will be an exact clone (deep copy) – SnakeDoc Feb 03 '14 at 16:10

score 8 · Answer 2 · answered Mar 11 '11 at 23:08

It is a shallow copy because it only copies reference to other objects. Say we have these classes :

class A {
    B variable
    A() {
        variable = new B();
    }
}

class B { }

And now we make a clone of an instance of A :

A firstA = new A();
A secondA = firstA.clone();

The B instance in firstA and secondA will be the same. You won't have a copy of the B instance. This is why clone() is said to do shallow copy.

The diagrams on the page you linked should help you understand all that.

score 5 · Answer 3 · answered Mar 11 '11 at 23:53

As an aside, I'm surprised nobody has mentioned Joshua Bloch's views on Cloneable

If you've read the item about cloning in my book, especially if you read between the lines, you will know that I think clone is deeply broken. There are a few design flaws, the biggest of which is that the Cloneable interface does not have a clone method. And that means it simply doesn't work: making something Cloneable doesn't say anything about what you can do with it. Instead, it says something about what it can do internally. It says that if by calling super.clone repeatedly it ends up calling Object's clone method, this method will return a field copy of the original.

score 4 · Answer 4 · answered Mar 11 '11 at 23:03

clone() creates copy of all fields. Java have primitive types and refences - when you clone your object you get a new object with copies of all primitive field (it is like deep copy) but also you have copy of all refernce fields. So in result you get two objects with they own copies of primitives and copies of references to the same objects - both original and copied object will use the same objects.

score 3 · Answer 5 · answered Mar 11 '11 at 23:02

Some objects do not provide a deep copy. For example, an ArrayList will clone the list, but not the elements in the list. The following is from the JavaDoc for ArrayList:

public Object clone()

    Returns a shallow copy of this ArrayList instance. (The elements themselves are not copied.)

score 2 · Answer 6 · edited May 23 '17 at 10:29

The default implementation of Object.clone() is a shallow copy. This behavior is still useful for types that have a large number of primitive fields or Immutable fields. You can look at How to properly override clone method? for how to properly override it. After calling super.clone(), then casting the resulting object, you can then clone deeper as needed.

Implicitly, the value of clone diminishes as the number of complex, mutable fields on your type increases.

score 1 · Answer 7 · answered Mar 11 '11 at 23:00

1

What clone does is defined for each object that chooses to support clone. Object.clone is protected, so no object allows clone unless someone has specifically defined it.

answered Mar 11 '11 at 23:00

bmargulies

97,814
39
186
310

score 0 · Answer 8 · answered Mar 11 '11 at 23:08

Yes.

But first you need that your class will implement Cloneable and throw exception

class A implements Cloneable{
    public int y;
    public B b;

    public A(){
        b = new B();
    }

    public static void main(String[] args) throws CloneNotSupportedException{
        A a = new A();
        A a2 = (A) a.clone();
        System.out.print(a.b==a2.b);
    }
}

Output: true

Is clone() in java shallow copy?

8 Answers8

Linked