HashMap的clone方法

         在网上看有关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对象新生成了一个数组。