在网上看有关HashMap的由关文章的时候,别人都说HashMap的clone方法是浅拷贝,但在看了源码后有所疑问,为什么HashMap的方法是浅拷贝呢?下面是对HashMap的clone方法的一个验证。
浅拷贝:对一个对象进行clone生成新的对象,新的对象要开辟一块新的内存来存储,新对象中的基本类型属性和String类型属性都会开辟新的空间存储,但是如果是引用类型的属性,那这个引用类型的属性还是指向原对象的引用属性内存,当对新的对象或原对象的引用属性做出改变的时候,两方的引用属性类型的值同时做出改变。
下面是对HAshMap的clone方法的验证
1.先申明一个bean作为引用类型
public class Student {
private String name;
private String sex;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student [name=" + name + ", sex=" + sex + ", age=" + age + "]";
}
public Student(){
}
public Student(String name, String sex, int age) {
super();
this.name = name;
this.sex = sex;
this.age = age;
}
}
2.调用main方法进行验证
package com.spring.test;
import java.util.HashMap;
import java.util.Hashtable;
import com.spring.bean.Student;
/**
* @author 作者 wangbiao
* @date 创建时间:2016年9月22日 下午4:41:17
* @parameter
* @return
*/
public class MapCloneTest {
public static void main(String[] args) {
Student zhangsan = new Student("zhangsan","男",25);
HashMap<Integer,Object> map = new HashMap<Integer,Object>();
map.put(1, zhangsan);
HashMap<Integer,Object> cloneMap = (HashMap<Integer, Object>) map.clone();
System.out.println("*************************不做改变***********************************");
System.out.println("未改变之前, map的值:"+map.toString());
System.out.println("未改变之前,cloneMap的值:"+cloneMap.toString());
System.out.println("map和cloneMap是否指向同一内存地址:"+(map==cloneMap));
System.out.println("map和cloneMap中存储的student是否指向同一内存地址:"+(map.get(1)==cloneMap.get(1)));
//对cloneMap中的值进行改变,看是否能影响到map
Student cloneLisi = (Student) cloneMap.get(1);
cloneLisi.setSex("女");
System.out.println("*************************对map中的值做出修改****************************");
System.out.println("改变之后,cloneMap的值:"+cloneMap.toString());
System.out.println("改变之后, map的值:"+map.toString());
System.out.println("*************************对map新增**********************************");
Student lisi = new Student("lisi","男",18);
map.put(2, lisi);
System.out.println("改变之后,cloneMap的值:"+cloneMap.toString());
System.out.println("改变之后, map的值:"+map.toString());
}
}
从HashMap的克隆方法可以看出这样的几点
1.HashMap的clone方法生成新的对象,新的对象有自己独立的存储空间。
2.虽然HashMap的clone方法生成了新的对象,但新的HashMap和原来的HashMap所存储的引用类型都是指向的同一存储空间。
3.新生成的HashMap中的数组属性table是开辟了新的空间的,只是table中的存储的值所指向的内存空间和原来的是一样的。这和我理解的浅拷贝的有点不一样。我理解的浅拷贝认为是对象中的引用属性指向的是同一内存地址,但HashMap中的table数组却不是指向同一地址,而是table里面的值指向同一地址。
HashMap的clone方法源码
/**
* Returns a shallow copy of this <tt>HashMap</tt> instance: the keys and
* values themselves are not cloned.
*key和value不被复制
* @return a shallow copy of this map
*/
public Object clone() {
HashMap<K,V> result = null;
try {
result = (HashMap<K,V>)super.clone();
} catch (CloneNotSupportedException e) {
// assert false;
}
//新申明了一个数组,这说明两个hashMap的数组不是指向的通一个对象
result.table = new Entry[table.length];
result.entrySet = null;
result.modCount = 0;
result.size = 0;
result.init();
//将原HashMap中存储的元素复制到新的HashMap里面
result.putAllForCreate(this);
return result;
}
//遍历原HashMap
private void putAllForCreate(Map<? extends K, ? extends V> m) {
for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
putForCreate(e.getKey(), e.getValue());
}
//将key-value放入新的数组中
private void putForCreate(K key, V value) {
int hash = null == key ? 0 : hash(key);
int i = indexFor(hash, table.length);
/**
* Look for preexisting entry for key. This will never happen for
* clone or deserialize. It will only happen for construction if the
* input Map is a sorted map whose ordering is inconsistent w/ equals.
*/
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
e.value = value;
return;
}
}
createEntry(hash, key, value, i);
}
void createEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
//这里如果value是引用类型,这里就是引用传递
table[bucketIndex] = new Entry<>(hash, key, value, e);
size++;
}
从源码中可以看出clone方法虽然生成了新的HashMap对象,新的HashMap中的table数组虽然也是新生成的,但是数组中的元素还是引用以前的HashMap中的元素。这就导致在对HashMap中的元素进行修改的时候,即对数组中元素进行修改,会导致原对象和clone对象都发生改变,但进行新增或删除就不会影响对方,因为这相当于是对数组做出的改变,clone对象新生成了一个数组。