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)的方法来重新产生对象的状态。