Java Clone, Shallow Copy and Deep Copy

Clone (κλών) is a Greek word meaning “branch”, referring to the process whereby a new plant can be created from a twig. In biology it is about copying the DNAs. In real world, if you clone Marilyn Monroe, will you get a copy of her with same beauty and characteristics? No, you will not get! This exactly applies to java also. See how java guys are good at naming technologies.

Marilyn-Monroe

In java, though clone is ‘intended’ to produce a copy of the same object it is not guaranteed. Clone comes with lots of its and buts. So my first advice is to not depend on clones. If you want to provide a handle / method to deliver a copy of the current instance write a kind of factory method and provide it with a good documentation. When you are in a situation to use a third party component and produce copies of it using the clone method, then investigate that implementation carefully and get to know what is underlying. Because when you ask for a rabbit, it may give monkeys!

Shallow Copy

Generally clone method of an object, creates a new instance of the same class and copies all the fields to the new instance and returns it. This is nothing but shallow copy. Object class provides a clone method and provides support for the shallow copy. It returns ‘Object’ as type and you need to explicitly cast back to your original object.

Since the Object class has the clone method (protected) you cannot use it in all your classes. The class which you want to be cloned should implement clone method and overwrite it. It should provide its own meaning for copy or to the least it should invoke the super.clone(). Also you have to implement Cloneable marker interface or else you will get CloneNotSupportedException. When you invoke the super.clone() then you are dependent on the Object class’s implementation and what you get is a shallow copy.

Deep Copy

When you need a deep copy then you need to implement it yourself. When the copied object contains some other object its references are copied recursively in deep copy. When you implement deep copy be careful as you might fall for cyclic dependencies. If you don’t want to implement deep copy yourselves then you can go for serialization. It does implements deep copy implicitly and gracefully handling cyclic dependencies.

Ads by Google

One more disadvantage with this clone system is that, most of the interface / abstract class writers in java forget to put a public clone method. For example you can take List. So when you want to clone their implementations you have to ignore the abstract type and use actual implementations like ArrayList by name. This completely removes the advantage and goodness of abstractness.

When implementing a singleton pattern, if its superclass implements a public clone() method, to prevent your subclass from using this class’s clone() method to obtain a copy overwrite it and throw an exception of type  CloneNotSupportedException.

Note that clone is not for instantiation and initialization. It should not be synonymously used as creating a new object. Because the constructor of the cloned objects may never get invoked in the process. It is about copying the object in discussion and not creating new. It completely depends on the clone implementation. One more disadvantage (what to do there are so many), clone prevents the use of final fields. We have to find roundabout ways to copy the final fields into the copied object.

Clone is an agreement between you, compiler and implementer. If you are confident that you all three have good knowledge of java, then go ahead and use clone. If you have a slightest of doubt better copy the object manually.

Example source code for java clone and shallow copy

class Employee implements Cloneable {

 private String name;
 private String designation;

 public Employee() {
 this.setDesignation("Programmer");
 }
 public String getDesignation() {
 return designation;
 }

 public void setDesignation(String designation) {
 this.designation = designation;
 }

 public String getName() {
 return name;
 }

 public void setName(String name) {
 this.name = name;
 }

 public Object clone() throws CloneNotSupportedException {
 /*
 Employee copyObj = new Employee();
 copyObj.setDesignation(this.designation);
 copyObj.setName(this.name);
 return copyObj;
 */
 return super.clone();
 }
}

public class CloneExample {
 public static void main(String arg[]){
 Employee jwz = new Employee();
 jwz.setName("Jamie Zawinski");
 try {
 Employee joel = (Employee) jwz.clone();
 System.out.println(joel.getName());
 System.out.println(joel.getDesignation());
 } catch (CloneNotSupportedException cnse) {
 System.out.println("Cloneable should be implemented. " + cnse );
 }
 }
}

Output of the above program:

Jamie Zawinski
Programmer

This Core Java tutorial was added on 28/09/2009.

«

»

Comments on “Java Clone, Shallow Copy and Deep Copy”

  1. Matt

    Great work Joe! Your are nicely mixing technology and humor. Its an interesting read.

  2. Evan Heather

    In your example source code, why is a block of code commented? Any particular meaning for that? It will help if you add a comment!

  3. Joe

    Commented part does the same work done by super.clone() – just to showcase that I have added that in comment.

  4. som

    what is the difference between the above code and this code
    Employee joel = jwz;
    System.out.println(joel.getName());
    System.out.println(joel.getDesignation());

    Both give the same output.

  5. Joe

    Som, you have not cloned the object. That is you have not acquired a copy of the object. Instead you have assigned the reference of that object to a new variable. Eventually pointing to same memory location. Therefore you get the same output!

    In my code I get the same output because java clone not only copies object meta data, it also copies value of attributes.

    I suggest you an experiment! Add one more attribute to Employee class. After clone set a value to original object’s attribute. Now print new object’s attribute and see if that value is reflected. Do this in my code and then in your code. This will help to clear your doubt on java clone, shallow copy and deep copy.

  6. som

    That was a valuable suggestion Joe. Thank you so much. I have another doubt. Can you please list some applications of shadow and deep copy or where they might be used?

  7. Joe

    Application of shallow copy or deep copy depends on business needs. Unless your business logic explicitly needs deep copy, you can always go for shallow copy.

  8. manoj

    useful article and thanks for posting it
    Can you give an example for this “When implementing a singleton pattern, if its superclass implements a public clone() method, to prevent your subclass from using this class’s clone() method to obtain a copy overwrite it and throw a CloneNotSupportedException.”

    • Prasanth Pillai

      Manoj,

      In your singleton class, overwrite the clone method, something like this

      public Object clone(){
      throw CloneNotSupportedException();
      }

  9. Anonymous

    three disadvantage given is cool…

    Dipanshu

  10. Rob Poole

    Nice, but it wasn’t too hard to notice that you name-dropped Jamie Zawinski in your source code (right down to using his usual Internet handle, jwz, as a variable name). Now, it’s possible you wrote this code all on your own and you thought it would be cheeky fun to name-drop someone who’s a co-founder of both Netscape and Mozilla.org, but based on my experiences, I find it more likely that the code was plagiarized from someone else’s example.

    This makes me wonder what else was plagiarized, if the example code looks suspect. Again, maybe I’m wrong, but I’m just saying what it looks like to me. I’ve seen a lot of tech blogs and websites out there that recycle other people’s content as their own, often without even giving proper attribution (and in some cases charging for access to content that isn’t theirs in the first place!).

    Now, if you *did* write that code… well, I hope JWZ isn’t a litigious sort of person. It’s kind of considered bad form to drop someone else’s name in sample code, unless you have a close relationship with that person and/or you have some kind of rivalry with them.

    Now, as to your article’s contents…

    “When implementing a singleton pattern, if its superclass implements a public clone() method, to prevent your subclass from using this class’s clone() method to obtain a copy overwrite it and throw a CloneNotSupportedException.”

    The word here is override, not overwrite. Big difference in semantics.

    “One more disadvantage with this clone system is that, most of the interface / abstract class writers in java forget to put a public clone method.”

    They didn’t “forget” to do it. The clone method belongs to the Object class, and must be overridden. Abstract classes will have this method inherited from Object, but it’s a protected method, and the abstract class — by definition — won’t have all details implemented that a concrete subclass has. The point is, an abstract superclass would need to know implementation details of concrete subclasses, which is a big no-no, just in order to implement clone(). Better to defer that implementation to the concrete subclass, which may possess fields and other methods not present in the abstract superclass.

    By the same token, it should now be obvious why an interface can not contain clone() as a method — first, there is already a protected clone() method in Object which you must override, and secondly, the Cloneable interface is what marks an object as being capable of being cloned, but an interface (the hypothetical interface we’re talking about, not the Cloneable interface) can’t make guarantees about the implementation logic of classes that implement it. The implementing class still needs to override Object.clone() no matter what.

  11. piotr

    I found the above text on this page: //interviewboard.wordpress.com/page/3/

    Someone is plagiarising. Thanks for that, otherwise I would not find this information. :)

  12. Anonymous

    Joe, Nice explanation about cloning.
    It would have been nice, if you had given example of deep cloning as well.

  13. Santosh

    Not only this concept every topic on this site is too good.

  14. Anonymous

    hey can any1 tell me how can we print the value of PI in java without using Math class i.e. without using Math.PI…???

  15. Snehal

    hey can u plz tel me how can we print d value of PI without using Math class i.e. without using Math.PI…???

  16. this example is so nice and managed environment. pls helps for these line we r also java developer. thanks

  17. rajesh khore

    well explained sir thanks

  18. Anonymous

    Very Nice Explained….
    Thanks Sir.

  19. Anonymous

    what exactly is the difference between shallow cloning and deep cloning?

  20. sukhdev

    Excellent article, Great job

  21. Rahul Barve

    The cloning concept is clearly, to the point explained. Great work!! Thanks!!

  22. Mahmood Alam Siddiqui

    First of all I wants to say thanks for so good explanation.

  23. Could you provide code for deep copy, if u can ? Thanks

  24. Shrikanth

    Thanks for the detailed one on clone. Where cloning (shallow or deep) is used ? Any one practical situation or business need demanding cloning ? Please give situation.

    Very much thanks for yours Java Blogs.

    Thanks,
    Shrikanth

  25. Velu

    It is nice !

  26. leena

    Liked the head first style

  27. Akki

    It would be helpful if you provide example of deep cloning

  28. prasad

    Nice article

  29. Jadumani

    Can I create singleton class as a clonable??
    If we create clone of singleton class then what is the purpose of class to make a singleton.

  30. Anonymous

    Very good description joe. From the above article, i can say cloning is use for making a clone object. Can you please tell me the scenario where java is actually using cloning concept.Please give some example also.

    Regards,
    Ashok

  31. Anonymous_2

    I dont understand the difference of shallow and deep copy. If we copy your code and implement the deep copy clone then output will be the same. We need to add one object reference to the Employee object then we can understand the difference.

  32. manoj

    Really its great topic ….
    U explained nicely…. thanks a lot.
    Thanks
    manoj CITE

  33. manu

    hi please give one example of deep copy…
    it would be better

  34. Anonymous

    Deep clone : You will have to override the clone method in each of the classes that the class to be cloned is composed of.
    The below example is just to illustrate the deep clone.

    package clone;

    public class Customer implements Cloneable{

    String name;
    Order order;
    public Customer(String name, Order order) {
    super();
    this.name = name;
    this.order = order;
    }

    public Order getOrder() {
    return order;
    }

    public void setOrder(Order order) {
    this.order = order;
    }

    public String getName() {
    return name;
    }

    public void setName(String name) {
    this.name = name;
    }

    public Customer() {
    super();
    // TODO Auto-generated constructor stub
    }

    public Customer(String name) {
    super();
    this.name = name;
    }

    @Override
    public Object clone(){
    try {
    Customer clonedCustomer = (Customer)super.clone();
    clonedCustomer.setOrder((Order)order.clone());
    return clonedCustomer;
    } catch (CloneNotSupportedException e) {
    e.printStackTrace();
    }
    return null;
    }

    }

    package clone;

    public class Order implements Cloneable {

    Item item;

    public Order(Item item) {
    super();
    this.item = item;
    }

    public Item getItem() {
    return item;
    }

    public void setItem(Item item) {
    this.item = item;
    }

    @Override
    public Object clone(){
    try {
    Order clonedOrder = (Order)super.clone();
    clonedOrder.setItem((Item)item.clone());
    return clonedOrder;

    } catch (CloneNotSupportedException e) {
    e.printStackTrace();
    }
    return null;
    }

    }

    package clone;

    public class Item implements Cloneable {

    String itemName;

    public Item(String itemName) {
    super();
    this.itemName = itemName;
    }

    public String getItemName() {
    return itemName;
    }

    public void setItemName(String itemName) {
    this.itemName = itemName;
    }
    @Override
    public Object clone(){
    try {
    return super.clone();
    } catch (CloneNotSupportedException e) {
    e.printStackTrace();
    }
    return null;
    }
    }

    package clone;

    public class ShallowCloneTest {

    /**
    * @param args
    */
    public static void main(String[] args) {
    Customer cust = new Customer(“Cust001″, new Order(new Item(“Item001″)));
    System.out.println(“original object :” + cust);
    Customer cloned = (Customer)cust.clone();
    System.out.println(“cloned object :” + cloned);
    cloned.getOrder().getItem().setItemName(“Item002″);
    cloned.setName(“Cust002″);
    System.out.println(“original object :” + cust.getOrder().getItem().getItemName());
    System.out.println(“original object :”+ cust.getName());
    }

    }

  35. Anonymous

    Hi Joe,

    According to you and javadoc Object class clone method provides a shallow copy.

    Shallow copy is the copy which shares the same memory location. but in case of clone java creates a new object(seperate memory location) and copies all the properties of the actual object to new object. I am really very confused.

    http://docs.oracle.com/javase/6/docs/api/java/lang/Object.html#clone%28%29

    if you see this link it clearly says that clone creates shallow copy and a new object with copied properties

    but if you see this link

    http://en.wikipedia.org/wiki/Object_copy

    it says that shallow copy shares same memory location and change in one object can change state of copied object

    but when i used cloned object and changed value of actual object it did not had any impact on cloned object

    Please help…

    • Kailah Chandra Das

      In case of Shallow clone, if the primitives are copied and reference variable except String(as immutable) are reused in cloned object. So if we modify primitive values in one object,it does not reflect in another object but if we modify reference vlues in cloned object, same value also available in original object.
      From this we sure that primitives are copied and reference variable(not String) are shared or reused in cloned object.

  36. Madhav

    Hi Joe
    whatever Anonymous tells is valid point , even I am also getting confused to understarnd differences between deep and shallow clones , Please still more clear
    in memory locations perspective,
    but whaterver disadvantages explained are very good

  37. Satish

    Not that much clear ;(

  38. Sameer

    Can someone explain the statement with some example which says “clone prevents the use of final fields.”
    But cloned object retains the value of final fields also along with other member variables.

  39. saravana

    excellent posting.

  40. swati

    really this site gives a perfect answer … i like it..

  41. Anonymous

    awesome explanation….useful…i added the site to my favourites :)

    anjana..

  42. Raghu

    Some Articles Posted by Joe are very good, I think this Cloning part is quite confusing for me. I gone through Some other link which is more clear in explaining the difference.

    Check the below link which is very useful. I think this will really help you all.

    http://www.jusfortechies.com/java/core-java/deepcopy_and_shallowcopy.php

  43. Raghu

    Some Articles Posted by Joe are very good, I think this Cloning part is quite confusing for me. I gone through some other website which is more clear in explaining the difference.

    Check the below link which is very useful.

    http://www.jusfortechies.com/java/core-java/deepcopy_and_shallowcopy.php

  44. Shanthi

    Sameer

    clone() comes with default constructor which doesn’t have any arguments in that case its impossible to initialize final variables.

  45. Avinash

    ==========================================
    Since the Object class has the clone method (protected) you cannot use it in all your classes
    ==========================================

    Can you give example of a class where clone() can’t be used.
    Since Object is the super class of all java classes clone should be supported by all classes.

  46. suryaprakash

    Thank Joe.

    Very useful article .

  47. Swetha

    Well.. perfect explanation.. Thank you…

  48. Anonymous

    its supper example

  49. Aman

    Thank you Sir!
    Aman Kumar
    Bangalore

  50. Anonymous

    this blog is very useful..

  51. Really a nice article!

  52. Anonymous

    rocking joe, this blog will help us to become masters in java…

  53. Navin

    Hi Joe,

    Hope you are doing good.

    I am referring to the statement “Clone comes with lots of its and buts.”

    In that perhaps its is ifs ? If Yes then it can be corrected :)

    Thanks for this Cloning stuffs.

    Regards
    Navin

  54. nilesh

    I have a query regarding limitation of Final.
    I am using JDK7 and used parameter as below.
    private final String imFinal;
    which is initialized in constructor as
    this.imFinal = “I am final”;
    Now after cloning this object, I can print value of final parameter using cloned object.
    So it looks like there is no limitation on Final. Please clarify.

  55. mani

    hello sir ::::

    i want to jdbc concept in driver .how to create in 4 drivers and setting.in simple way

    plz send my mail

  56. Ravikiran Mane

    Just visited the page Rob pointed out :
    //interviewboard.wordpress.com/page/3/

    however, it contains hyperlinks to your blog.

    Wanted to verify if the work was plagiarized but {THANK GOD} was good to learn it’s not!

    I have been referring to various blogs of yours, thank you for your work.

    #Respect

  57. nikhil

    I have a doubt a)Object class has clone method,b)Implicitly all classes extends Object class.Then why is it neccessary to implement Clonable interface.

    • Kailah Chandra Das

      Cloneable interface is a marker interface having no method. The class which implement this interface get special status so that JVM can mark this class will be cloned.

  58. siddu

    super joe……………..

  59. satish kumar

    I like the comment “Because when you ask for a rabbit, it may g”””ive monkeys!”

  60. ripon

    Thanks a lot! You make a complex concept very simple.

  61. Ashutosh Kumar

    How clone prevent use of final field

  62. Guru

    When implementing a singleton pattern
    if its superclass implements a public clone() method,
    to prevent our subclass from using this class’s clone() method to obtain a copy
    while overwrite clone method, Do we need to throw an exception of type CloneNotSupportedException?

    I feel if we class same static getInstance() factory method will server the purpose.

    Please correct me if my understanding is wrong.

  63. Nice Explanation joe… thanks for guidelines.

  64. sravya

    /*
    Employee copyObj = new Employee();
    copyObj.setDesignation(this.designation);
    copyObj.setName(this.name);
    return copyObj;
    */
    clone method does not call constructor. in the above code the first line is calling the default constructor. then how will the above code is equivalent to super.clone()? can u pls explain if i am wrong.

  65. Anil

    Joey,I was experimenting with your code.
    What I found that we need not to override clone method. Only implementing Cloneable interface.Then calling obj.clone will work.
    Is there any particular reason why we should override this method?

    • sunil

      Joey, Cloneable interface is a marker interface and it doesnt have any methods it is just to intimate the compiler that this class is eligible for creating clone object. Even clone() is ‘Object’ class method and ‘Object’ class is super class in Class heirarchy we cannot override clone method directly it will throw CloneNotSupportedException, the main reason is to avoid making every class as Cloneable.

  66. utkarsh

    Good Work..
    Good Example
    & Good Explanation..:)

  67. super example sir, the way you explain is very nice, it gives me visual representation of how the flow goes, thanks lot

  68. bijna

    if i add some static field like age.if we using the commented section then update it in using clone object not updated in its main object.

  69. Swapnil

    Hi joe,

    I was reding this article to understand the ways to deep copy an object “Java Clone, Shallow Copy and Deep Copy”

    Unfortuntely in this article there is no single way mentioned to deep copy an object. Can you include at least one implementation for that here?

    It will also clear a lot of questions like what is the difference between Deep Copy and Shallow Copy.

    Thanks,
    Swapnil

  70. Uvaraj

    Hi Joe,
    I have edited the code that you had given,
    still I am getting the same output,
    in that case can you please explain how cloning really works.

    class Employee{
    private String name;
    private String designation;

    public Employee() {
    this.setDesignation(“Programmer”);
    }
    public String getDesignation() {
    return designation;
    }

    public void setDesignation(String designation) {
    this.designation = designation;
    }

    public String getName() {
    return name;
    }

    public void setName(String name) {
    this.name = name;
    }
    }

    public class ShallowCopy {
    public static void main(String arg[]){
    Employee employee = new Employee();
    employee.setName(“Uvaraj”);
    //employee.setDesignation(“Senior Developer”);
    try {
    System.out.println(employee.getName());
    System.out.println(employee.getDesignation());
    } catch (Exception e) { System.out.println(“Cloneable should be implemented. ” + cns);
    }
    }
    }

  71. Dilip Senapati

    A very good explanation on the topic. Thanks Joe.

  72. Anonymous

    you have mentioned that cloning not invoke the constructor. but your code in clone method
    public Object clone() throws CloneNotSupportedException {
    /*
    Employee copyObj = new Employee();
    copyObj.setDesignation(this.designation);
    copyObj.setName(this.name);
    return copyObj;
    */
    return super.clone();
    }
    invoke the constructor.

    both statements are totally different.
    Do you have any comment.

  73. Selva

    This is really good example bass

  74. Selva

    Bass. Please tell us any one real time scenario using with clone

  75. Anonymous

    YOU ROCK!
    THANKS!

  76. I’m afraid I don’t understand this: “Since the Object class has the clone method (protected) you cannot use it in all your classes.”

    I thought a protected method was supposed to be accessible in all subclasses of the class that defines it.

  77. Vivek Gupta

    Hi Joe,

    in your post above you said :

    “Note that clone is not for instantiation and initialization. It should not be synonymously used as creating a new object. Because the constructor of the cloned objects may never get invoked in the process.”

    but in the implementation u shared, u also instantiated a new instance and initiated it by copying values.

    /*
    Employee copyObj = new Employee();
    copyObj.setDesignation(this.designation);
    copyObj.setName(this.name);
    return copyObj;
    */

    Isn’t that a self contradiction?

  78. Howdy just wanted to give you a quick heads up.
    The text in your post seem to be running off the screen in
    Internet explorer. I’m not sure if this is a format issue or something to do with web browser compatibility but I thought I’d post to let
    you know. The layout look great though! Hope you get the problem resolved soon.
    Many thanks

Your Comment