jdk7 HashSet和HashMap源码分析

先来看看HashMap的一些成员变量以及他们的含义

 /**
     * The default initial capacity - MUST be a power of two.
     */
    static final int DEFAULT_INITIAL_CAPACITY = 16;//默认Entry数组的长度

/**
     * The load factor used when none specified in constructor.
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;//加载因子，和数组长度有关

    /**
     * The table, resized as necessary. Length MUST Always be a power of two.
     */
    transient Entry<K,V>[] table;//HashMap底层实现就是Entry数组，以后说的数组就是这个数组

    /**
     * The number of key-value mappings contained in this map.
     */
    transient int size;  //添加元素的个数

HashSet的底层实现就是用HashMap实现的。

hashset的add方法就是用hashmap的put方法。key是添加的元素，value是hashset维护的一个常量。这里不多说了，主要还是分析HashMap的源代码。

    public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);//添加键为null的元素
        int hash = hash(key);//得到key的hash值，这个hash值是对key的hashcode进行过处理的
        int i = indexFor(hash, table.length);//根据hash值和数组长度得到元素保存到数组中的位置
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
//判断将要添加元素的位置是否有元素了
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
//根据hashcode和equals方法判断键是否重复了，如果键重复了，将值替换了，并返回原来的值。
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
//如果键不重复，则添加到数组中
        modCount++;
        addEntry(hash, key, value, i);//hash值，键，值，插入到数组的位置（索引）
        return null;
    }

    /**
     * Offloaded version of put for null keys
     */
    private V putForNullKey(V value) {
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null) {//添加的key为null，如果已经存在key为null的元素，则替换原来的值，返回旧值
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        addEntry(0, null, value, 0);//添加第一个key为null的元素
        return null;
    }

//可以看出，添加key为null的元素每次都是添加到数组的第一个位置，重复添加key为null的元素，新值替换旧值

void addEntry(int hash, K key, V value, int bucketIndex) {
        if ((size >= threshold) && (null != table[bucketIndex])) {
            resize(2 * table.length);//如果元素个数大于threshold（这个数是一个数乘以加载因子，与加载因子相乘的这个数与初始化数组长度有关） 扩容为原来的两倍
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);//得到一个新的位置
        }

        createEntry(hash, key, value, bucketIndex);
    }

   void createEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K,V> e = table[bucketIndex];//得到存在数组中该位置的元素
        table[bucketIndex] = new Entry<>(hash, key, value, e);//将新添加的元素存到该位置上，并关联之前保存在该位置上的数组
        size++;//元素个数+1
    }

    static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;
        V value;
        Entry<K,V> next;
        int hash;

        /**
         * Creates new entry.
         */
        Entry(int h, K k, V v, Entry<K,V> n) {
            value = v;
            next = n;
            key = k;
            hash = h;
        }
...
}
//Entry的结构

总结：当添加key为null的元素，会保存在数组的第一个位置上。其他key不为null的情况，是根据key的hash值来判断保存都Entry数组中的位置，如果该位置上没有元素，则直接添加。如果数组中已经在该位置上有元素了，根据hashcode和equals方法来判断键是否重复，如果重复，则替换旧值，并返回旧值。如果不重复，则将新元素添加到数组的索引上，然后通过Entry的next属性关联之前保存在该位置上的元素。当元素的个数大于某个值（不作详解）且该位置上有元素时，数组长度扩容为原来的两倍。

上面是添加元素，下面是取元素。

    public V get(Object key) {
        if (key == null)
            return getForNullKey();//获取键为null的值
        Entry<K,V> entry = getEntry(key);//根据key获取元素

        return null == entry ? null : entry.getValue();
    }

    private V getForNullKey() {
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;//返回key为null的值
        }
        return null;//如果不存在key为null，则返回null
    }

    final Entry<K,V> getEntry(Object key) {
        int hash = (key == null) ? 0 : hash(key);//得到key的hash值
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {//根据key的hash值来索引保存在数组中的位置，如果索引到的位置有元素，判断key是否一致，直到判断完该位置上的所有元素，如果都不匹配，则返回null。如果该位置上没有元素，则返回null。
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;//不存在key则返回null
    }