How To Clone Collection Inwards Coffee - Deep Re-Create Of Arraylist As Well As Hashset

Programmer oftentimes mistook re-create constructors provided past times diverse collection classes, equally a hateful to clone Collection e.g. List, Set, ArrayList, HashSet or whatever other implementation. What is worth remembering is that, re-create constructor of Collection inwards Java entirely provides shallow re-create in addition to non deep copy, which agency objects stored inwards both master List in addition to cloned List volition hold upward same in addition to betoken to same retention place inwards Java heap. One thing, which adds into this misconception is shallow re-create of Collections alongside Immutable Objects. Since Immutable can't hold upward changed, It's Ok fifty-fifty if 2 collections are pointing to same object. This is just the instance of String contained inwards pool, update on i volition non deport upon other.

Problem arise, when nosotros purpose Copy constructor of ArrayList to exercise  a clone of List of Employees, where Employee is non Immutable. In this case, if master collection modifies an employee, that alter volition also reverberate into cloned collection.

Similarly if an employee is modified inwards cloned collection, it volition also appeared equally modified inwards master collection. This is non desirable, inwards most all cases, clone should hold upward independent of master object. Solution to avoid this work is deep cloning of collection, which agency recursively cloning object, until yous reached to primitive or Immutable.

In this article, nosotros volition direct maintain a await at i approach of deep copying Collection classes e.g. ArrayList or HashSet in Java. By the way, If yous know difference betwixt shallow re-create in addition to deep copy, it would hold upward real tardily to empathize how deep cloning of collection works.

Deep Cloning of Collection inwards Java

In next example, nosotros direct maintain a Collection of Employee, a mutable object, alongside name and designation field. They are stored within HashSet. We exercise roughly other re-create of this collection using addAll() method of java.util.Collection interface. After that, nosotros modified designation of each Employee object stored inwards master Collection. Ideally this alter should non deport upon original Collection, because clone in addition to master object should hold upward independent of each other, only it does. Solution to ready this work is deep cloning of elements stored inwards Collection class.

import java.util.Collection; import java.util.HashSet; import java.util.Iterator; import org.slf4j.Logger; import org.slf4j.LoggerFactory;  /**    * Java programme to demonstrate re-create constructor of Collection provides shallow   * re-create in addition to techniques to deep clone Collection past times iterating over them.   * @author http://javarevisited.blogspot.com   */ public class CollectionCloningTest {     private static final Logger logger = LoggerFactory.getLogger(CollectionCloningclass);            public static void main(String args[]) {                 // deep cloning Collection inwards Java         Collection<Employee> org = new HashSet<>();         org.add(new Employee("Joe", "Manager"));         org.add(new Employee("Tim", "Developer"));         org.add(new Employee("Frank", "Developer"));                 // creating re-create of Collection using re-create constructor         Collection<Employee> re-create = new HashSet<>(org);                 logger.debug("Original Collection {}", org);         logger.debug("Copy of Collection  {}", re-create );                 Iterator<Employee> itr = org.iterator();         while(itr.hasNext()){             itr.next().setDesignation("staff");         }                 logger.debug("Original Collection afterward modification  {}", org);         logger.debug("Copy of Collection without modification {}", re-create );                 // deep Cloning List inwards Java            }    }  class Employee {     private String name;     private String designation;      public Employee(String name, String designation) {         this.name = name;         this.designation = designation;     }      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;     }      @Override     public String toString() {         return String.format("%s: %s", name, designation );     }       }  Output : - Original Collection [Joe: Manager, Frank: Developer, Tim: Developer] - Copy of Collection  [Joe: Manager, Frank: Developer, Tim: Developer] - Original Collection afterward modification  [Joe: staff, Frank: staff, Tim: staff] - Copy of Collection without modification [Joe: staff, Frank: staff, Tim: staff]

You tin encounter it clearly that modifying Employee object inwards master Collection (changed designation to "staff") is also reflecting inwards cloned collection, because clone is shallow re-create in addition to pointing to same Employee object inwards heap. In social club to ready this, nosotros quest to deep clone Employee object past times iterating over Collection in addition to earlier that, nosotros quest to override clone method for Employee object.

1) Let Employee implements Cloneable interface
2) Add next clone() method into Employee class

@Override     protected Employee clone() {         Employee clone = null;         try{             clone = (Employee) super.clone();                     }catch(CloneNotSupportedException e){             throw new RuntimeException(e); // won't happen         }                 return clone;             }

3) Instead of using Copy constructor purpose next code, to deep re-create Collection inwards Java

Collection<Employee> re-create = new HashSet<Employee>(org.size());         Iterator<Employee> iterator = org.iterator(); while(iterator.hasNext()){     copy.add(iterator.next().clone()); }

4) Running same code for modifying collection, volition non consequence inwards dissimilar output:

- Original Collection afterward modification  [Joe: staff, Tim: staff, Frank: staff]
- Copy of Collection without modification [Frank: Developer, Joe: Manager, Tim: Developer]

You tin encounter that both clone in addition to Collection are independent to each other in addition to they are pointing to dissimilar objects.

That's all on How to clone Collection inwards Java. Now nosotros know that re-create constructor or diverse collection classes e.g. addAll() method of List or Set, entirely creates shallow re-create of Collection, in addition to both master in addition to cloned Collection points to same objects. To avoid this, nosotros tin deep re-create collection, my iterating over them in addition to cloning each element. Though this requires that whatever object stored inwards Collection, must back upward deep cloning operation.


Further Learning
Complete Java Masterclass
Java Fundamentals: The Java Language
Java In-Depth: Become a Complete Java Engineer!

Share this post