Java HashTable的Cloneable实现

Java HashTable的Cloneable实现

我们都知道Cloneable是一个接口，实现这个接口，就可以创建一个对象的拷贝，但必须实现public A clone的方法。Object 终极父类中含有一个protected clone()的本地方法。在派生类的clone()方法中，可以调用super.clone()。因为在运行时刻，Object类中的clone()识别出你要复制的是哪一个对象，然后为此对象分配空间，并进行对象的复制，将原始对象的内容一一复制到新对象的存储空间中。

然而我们需要谨慎地覆盖clone方法。因为java.Object.clone()是一种浅拷贝。
浅拷贝：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。
换言之，浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象。

深拷贝：被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。

　　那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。

　　换言之，深拷贝把要复制的对象所引用的对象都复制了一遍。

对于类的每个域都是一个基本类型的值，或者包含一个指向不可变对象的引用。调用java.Object.clone()饭后的对象则可能是所需要的对象。例如：

public class Student implements Cloneable {

    private int id ;
    private String name ;


    public Student(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }


    public int getId() {
        return id;
    }


    public void setId(int id) {
        this.id = id;
    }


    public String getName() {
        return name;
    }


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

     @SuppressWarnings("unchecked")
    public Object clone() {
        // TODO Auto-generated method stub
         Student stu = null; 
        try {
            stu =   (Student)super.clone();

        } catch (CloneNotSupportedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return stu;
    }



    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "id: "+id+" name"+name;
    }


    public static void main(String[] args)
    {
        Student a = new Student(1, "高辉光");
        System.out.println(a);
        Student b = (Student)a.clone();
        System.out.println(b);
        b.setId(2);
        b.setName("辉光");
        System.out.println(a);
        System.out.println(b);
    }
}

程序输出的结果：
id: 1 name高辉光
id: 1 name高辉光
id: 1 name高辉光
id: 2 name辉光

从程序的输出结果可以看出
Student b 是由Student a克隆而得到，他们各自有自己的内存结构。修改b的id和name不会影响到a对象的。
如果对象中包含的域引用了可变的对象，使用上述这种简单的clone实现可能会导致灾难性的后果。例如我们在Student类里添加一个Address对象的引用。

class Address
{
    private String add ;

    public String getAdd() {
        return add;
    }

    public void setAdd(String add) {
        this.add = add;
    }

    public Address(String add) {
        super();
        this.add = add;
    }


}
public class Student implements Cloneable {

    private int id ;
    private String name ;
    private Address addr;



    public Student(int id, String name, Address addr) {
        super();
        this.id = id;
        this.name = name;
        this.addr = addr;
    }


    public Address getAddr() {
        return addr;
    }


    public void setAddr(Address addr) {
        this.addr = addr;
    }


    public int getId() {
        return id;
    }


    public void setId(int id) {
        this.id = id;
    }


    public String getName() {
        return name;
    }


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

     @SuppressWarnings("unchecked")
    public Object clone() {
        // TODO Auto-generated method stub
         Student stu = null; 
        try {
            stu =   (Student)super.clone();

        } catch (CloneNotSupportedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return stu;
    }



    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "id: "+id+" name:"+name +" addr:"+addr.getAdd();
    }


    public static void main(String[] args)
    {
        Student a = new Student(1, "高辉光",new Address("武汉"));
        System.out.println(a);
        Student b = (Student)a.clone();
        System.out.println(b);
        b.setId(2);
        b.setName("辉光");
        b.addr.setAdd("九江");
        System.out.println(a);
        System.out.println(b);
    }
}

程序输出的结果：
id: 1 name:高辉光 addr:武汉
id: 1 name:高辉光 addr:武汉
id: 1 name:高辉光 addr:九江
id: 2 name:辉光 addr:九江
从程序的输出结果可以看出
Student b是由Student a拷贝而得到，但这种拷贝是一种浅拷贝，Student类中有一个可变对象的引用，调用super.clone()方法只是简单地拷贝那个addr引用，Student b和Student a的addr同指向同一个对象，因此修改b.addr的值时会导致a.addr发生改变。

class Address implements Cloneable
{
    private String add ;

    public String getAdd() {
        return add;
    }

    public void setAdd(String add) {
        this.add = add;
    }

    public Address(String add) {
        super();
        this.add = add;
    }
    public Object clone()
    {
        Address addr = null;
        try {
            addr = (Address)super.clone();
        } catch (CloneNotSupportedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return addr;
    }

}
//Student类的clone方法
public Object clone() {
        // TODO Auto-generated method stub
         Student stu = null; 
        try {
            stu =   (Student)super.clone();
            stu.addr = (Address)this.addr.clone();
        } catch (CloneNotSupportedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return stu;
    }

程序输出的结果：
id: 1 name:高辉光 addr:武汉
id: 1 name:高辉光 addr:武汉
id: 1 name:高辉光 addr:武汉
id: 2 name:辉光 addr:九江

可以看出这才是真正的深拷贝。
再看了一下HashTable的克隆实现

public class Hashtable<K,V>
    extends Dictionary<K,V>
    implements Map<K,V>, Cloneable, java.io.Serializable {
       private transient Entry<?,?>[] table;
       private static class Entry<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Entry<K,V> next;

        protected Entry(int hash, K key, V value, Entry<K,V> next) {
            this.hash = hash;
            this.key =  key;
            this.value = value;
            this.next = next;
        }

        @SuppressWarnings("unchecked")
        protected Object clone() {
            return new Entry<>(hash, key, value,
                                  (next==null ? null : (Entry<K,V>) next.clone()));
        }

        // Map.Entry Ops

        public K getKey() {
            return key;
        }

        public V getValue() {
            return value;
        }

        public V setValue(V value) {
            if (value == null)
                throw new NullPointerException();

            V oldValue = this.value;
            this.value = value;
            return oldValue;
        }

        public boolean equals(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;

            return (key==null ? e.getKey()==null : key.equals(e.getKey())) &&
               (value==null ? e.getValue()==null : value.equals(e.getValue()));
        }

        public int hashCode() {
            return hash ^ Objects.hashCode(value);
        }

        public String toString() {
            return key.toString()+"="+value.toString();
        }
    }
    }

  public synchronized Object clone() {
        try {
            Hashtable<?,?> t = (Hashtable<?,?>)super.clone();
            t.table = new Entry<?,?>[table.length];
            for (int i = table.length ; i-- > 0 ; ) {
                t.table[i] = (table[i] != null)
                    ? (Entry<?,?>) table[i].clone() : null;
            }
            t.keySet = null;
            t.entrySet = null;
            t.values = null;
            t.modCount = 0;
            return t;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        }
    }

Hashtable<?,?> t = (Hashtable<?,?>)super.clone();

调用父类的clone方法，浅拷贝一个HashTable对象t

t.table = new Entry<?,?>[table.length];

重新生成一个散列数组。

for (int i = table.length ; i-- > 0 ; ) {
                t.table[i] = (table[i] != null)
                    ? (Entry<?,?>) table[i].clone() : null;
            }

遍历原散列数组，，单独地拷贝并生成每个桶的链表。
再看一下Entry.clone方法

  protected Object clone() {
            return new Entry<>(hash, key, value,
                                  (next==null ? null : (Entry<K,V>) next.clone()));
        }  

Entry类中的深拷贝方法地跪地调用它自身，以便拷贝整个链表。虽然这种方法很灵活，如果散列桶不是很长的话，也会工作的很好，但是这样克隆一个链表斌不是一个好办法，因为针对列表中的每个元素，他都要消耗一段栈空间。如果链表比较长，这很容易导致栈溢出。为了避免发生这种情况，你可以在deepCopy中用迭代(iteration)代替递归(recursion)：

Entry deepCopy()
{
    Entry result = new Entry(key,value,next);
    for(Entry p = result;p.next!=null;p = p.next)
        p.next = new Entry(p.next.key,p.next.value,p.next.next);
    return result;
}

克隆复杂对象的一种方法是，先调用super.clone，然后把结果对象中的所有域都设置成他们的空白状态(virgin state)，然后调用高层(higher-level)的方法来重新产生对象的状态。