HashMap源码理解

HashMap的一些默认参数如下：

/**
     * The default initial capacity - MUST be a power of two.
     */
    static final int DEFAULT_INITIAL_CAPACITY = 16;

    /**
     * The maximum capacity, used if a higher value is implicitly specified
     * by either of the constructors with arguments.
     * MUST be a power of two <= 1<<30.
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;

    /**
     * The load factor used when none specified in constructor.
     */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

默认长度是16，最大容量的2的30次方，负载因子是0.75；如果数组中的数据量大于capacity*0.75时会进行扩容，数组长度增加为原来的2倍，并重新计算数组下标。

HashMap的底层接口是数组-链表形式的

 transient Entry<K,V>[] table;

再来看看Entry<k,v>是什么？

截取的一部分：

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

Entry里面存的有map的key、value还有指向下一个节点的指针，那么这个hash是什么？还得先看一下map的put和get方法里面的使用。先看看get

 public V get(Object key) {
        if (key == null)
            return getForNullKey();
        Entry<K,V> entry = getEntry(key);

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

再看看getEntry:

/**
     * Returns the entry associated with the specified key in the
     * HashMap.  Returns null if the HashMap contains no mapping
     * for the key.
     */
    final Entry<K,V> getEntry(Object key) {
        int hash = (key == null) ? 0 : hash(key);
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                return e;
        }
        return null;
    }

map.get(key)的过程基本思想：先计算key的hash值，再使用indexFor计算出一个值作为数组的下标取出链表Entry，循环遍历Entry比对hash值和key，都一致者说明找到正确的对象，返回entry.getValue().

那么hash是怎么计算的？以及，index是什么？看下面：

final int hash(Object k) {
        int h = 0;
        if (useAltHashing) {
            if (k instanceof String) {
                return sun.misc.Hashing.stringHash32((String) k);
            }
            h = hashSeed;
        }

        h ^= k.hashCode();

        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

还有indexFor：

 /**
     * Returns index for hash code h.
     */
    static int indexFor(int h, int length) {
        return h & (length-1);
    }

hash是上面根据key计算的值，length不是数组的容量，而是目前存入值的个数。

链表新增一个节点时放在头节点前，把之前的头节点设为自己的nest。

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：因为HashMap可以接受null键值和值，所以当key为mull是存在table[0]这个位置上，因为hash值一定位0。

2：重新调整HashMap大小存在什么问题？

当多线程的情况下，可能产生条件竞争，因为如果两个线程都发现HashMap需要重新调整大小了，它们会同时试着调整大小。在调整大小的过程中，存储在LinkedList中的元素的次序会反过来，因为移动到新的bucket位置的时候，HashMap并不会将元素放在LinkedList的尾部，而是放在头部，这是为了避免尾部遍历(tail traversing)。如果条件竞争发生了，那么就死循环了。 （多线程用CocurrentHashMap）