How To Clone Collection Inwards Coffee - Deep Re-Create Of Arraylist In Addition To Hashset

Programmer oftentimes mistook re-create constructors provided yesteryear 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 solely provides shallow re-create together with non deep copy, which agency objects stored inwards both master copy List together with cloned List volition survive same together with betoken to same retentivity place inwards Java heap. One thing, which adds into this misconception is shallow re-create of Collections amongst Immutable Objects. Since Immutable can't survive changed, It's Ok fifty-fifty if 2 collections are pointing to same object. This is just the representative of String contained inwards pool, update on ane volition non deport on 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 copy 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 copy collection. This is non desirable, inwards around all cases, clone should survive independent of master copy object. Solution to avoid this occupation is deep cloning of collection, which agency recursively cloning object, until you lot reached to primitive or Immutable.

In this article, nosotros volition accept a await at ane approach of deep copying Collection classes e.g. ArrayList or HashSet in Java. By the way, If you lot know difference betwixt shallow re-create together with deep copy, it would survive real slowly to empathise how deep cloning of collection works.

Deep Cloning of Collection inwards Java

In next example, nosotros own got a Collection of Employee, a mutable object, amongst name and designation field. They are stored within HashSet. We exercise to a greater extent than or less 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 copy Collection. Ideally this alter should non deport on original Collection, because clone together with master copy object should survive independent of each other, only it does. Solution to cook this occupation 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 together with techniques to deep clone Collection yesteryear 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 come across it clearly that modifying Employee object inwards master copy Collection (changed designation to "staff") is also reflecting inwards cloned collection, because clone is shallow re-create together with pointing to same Employee object inwards heap. In lodge to cook this, nosotros involve to deep clone Employee object yesteryear iterating over Collection together with earlier that, nosotros involve 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 upshot inwards unlike output:

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

You tin come across that both clone together with Collection are independent to each other together with they are pointing to unlike 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, solely creates shallow re-create of Collection, together with both master copy together with cloned Collection points to same objects. To avoid this, nosotros tin deep re-create collection, my iterating over them together with cloning each element. Though this requires that whatever object stored inwards Collection, must back upwards deep cloning operation.


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

Sumber https://javarevisited.blogspot.com/

Share this post