java集合克隆

参考：ImportNew的博客，网址：http://www.importnew.com/10761.html

参考：hejiani的博客，网址：http://www.importnew.com/10761.html

 

集合克隆，如对不可变对象的克隆如String对象（克隆均为浅克隆），浅拷贝和深拷贝都是一样的，改变原始对象或者改变拷贝对象对另一个没有影响。如果拷贝的为可改变对象，如职员对象等，改变一个会对另一个拷贝对象有影响，则需要深拷贝。

 

一、不可变对象的克隆

      Set<String> newSet=new LinkedHashSet<String>(); //原始对象

    ......

    Set<String> newSetClone=new HashSet(newSet);  //新的拷贝对象，此时拷贝对象与原始对象，在更改时，互不影响。

例子：因String为不可改变对象，则拷贝对象与原始对象各自更改相互不影响。

package com.test;

import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;

import com.model.Staff;

public class SetClone {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Set<String> newSet=new LinkedHashSet<String>();
        Set<String> oldSet=new LinkedHashSet<String>();
        newSet.add("相同1");
        newSet.add("相同2");
        newSet.add("新来1");
        newSet.add("新来2");

        oldSet.add("相同1");
        oldSet.add("相同2");
        oldSet.add("离职1");
        oldSet.add("离职2");
        Set<String> newSetClone=new HashSet(newSet); 
        Set<String> oldSetClone=new HashSet(oldSet);
        
        newSet.removeAll(oldSet);
        oldSetClone.removeAll(newSetClone);   
        System.out.println("原始新值"+newSet);
        System.out.println("原始旧值"+oldSet);
        System.out.println("新增的为："+newSet);
        System.out.println("需删除的为："+oldSetClone);
    }

}
 

输出为：

原始新值[新来1, 新来2]
原始旧值[相同1, 相同2, 离职1, 离职2]
新增的为：[新来1, 新来2]
需删除的为：[离职1, 离职2]
 

 

 

二、可变对象克隆

 

对象克隆：

Collection<Employee> org = new HashSet<Employee>(); 

.......

Collection<Employee> copy = new HashSet<Employee>(org);
 

浅拷贝，当原始对象更改后，拷贝对象也会随着更改。

package com.test;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;

public class CollectionShallowCloningTest {

     public static void main(String args[]) { 
        // deep cloning Collection in Java 
        Collection<Employee> org = new HashSet<Employee>(); 
        org.add(new Employee("原始用户1", "Manager")); 
        org.add(new Employee("原始用户2", "Developer")); 
        org.add(new Employee("原始用户3", "Developer")); 
 
        // creating copy of Collection using copy constructor 
        Collection<Employee> copy = new HashSet<Employee>(org);
 
        System.out.println("原始集合为:"+ org); 
        System.out.println("拷贝为："+ copy );
         
        Iterator<Employee> itr = org.iterator(); 
        while(itr.hasNext()){ 
            itr.next().setDesignation("staff"); 
        } 
 
        //一个的更改，拷贝后的另一个也更改，不符合语义，此为浅拷贝
        System.out.println("原始职位更改staff后：原始集合为:"+ org); 
        System.out.println("原始职位更改staff后：拷贝为："+ copy ); 
 
        // deep Cloning List in Java 
 
        
        
    } 
}
 

输出为：

 

原始集合为:[原始用户1: Manager, 原始用户3: Developer, 原始用户2: Developer]
拷贝为：[原始用户1: Manager, 原始用户3: Developer, 原始用户2: Developer]
原始职位更改staff后：原始集合为:[原始用户1: staff, 原始用户3: staff, 原始用户2: staff]
原始职位更改staff后：拷贝为：[原始用户1: staff, 原始用户3: staff, 原始用户2: staff]
 

-------*********************************

深拷贝，当原始对象改变时，拷贝对象不改变，需重写clone方法，对象实现Cloneable接口。

public class EmployeeDeepCopy implements Cloneable{

}

 Collection<EmployeeDeepCopy> copy = new HashSet<EmployeeDeepCopy>(org.size());
        Iterator<EmployeeDeepCopy> iterator1 = org.iterator(); 
        while(iterator1.hasNext()){
            copy.add(iterator1.next().clone());
        }

代码为：

package com.test;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;

public class CopyOfCollectionDeepCloningTest {

     public static void main(String args[]) { 
        // deep cloning Collection in Java 
        Collection<EmployeeDeepCopy> org = new HashSet<EmployeeDeepCopy>(); 
        org.add(new EmployeeDeepCopy("原始用户1", "Manager")); 
        org.add(new EmployeeDeepCopy("原始用户2", "Developer")); 
        org.add(new EmployeeDeepCopy("原始用户3", "Developer")); 
 
        // creating copy of Collection using copy constructor 
 
        Collection<EmployeeDeepCopy> copy = new HashSet<EmployeeDeepCopy>(org.size());
        Iterator<EmployeeDeepCopy> iterator1 = org.iterator(); 
        while(iterator1.hasNext()){
            copy.add(iterator1.next().clone());
        }
        
        System.out.println("原始集合为:"+ org); 
        System.out.println("拷贝为："+ copy );
         
        Iterator<EmployeeDeepCopy> itr = org.iterator(); 
        while(itr.hasNext()){ 
            itr.next().setDesignation("staff"); 
        } 
 
        //一个的更改，拷贝后的另一个也更改，不符合语义，此为浅拷贝
        System.out.println("原始职位更改staff后：原始集合为:"+ org); 
        System.out.println("原始职位更改staff后：拷贝为："+ copy ); 
 
        // deep Cloning List in Java 
 
        
        
    } 
}
输出为：

原始集合为:[原始用户1: Manager, 原始用户3: Developer, 原始用户2: Developer]
拷贝为：[原始用户1: Manager, 原始用户3: Developer, 原始用户2: Developer]
原始职位更改staff后：原始集合为:[原始用户1: staff, 原始用户3: staff, 原始用户2: staff]
原始职位更改staff后：拷贝为：[原始用户1: Manager, 原始用户3: Developer, 原始用户2: Developer]
 

其他代码：

package com.test;

public 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 ); 
        } 

}
 

package com.test;

public class EmployeeDeepCopy implements Cloneable{

    private String name; 
    private String designation; 
     
    public EmployeeDeepCopy(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 ); 
    } 
    
    @Override
    protected EmployeeDeepCopy clone(){

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

    }
    
    
    
}