当我们向HashMap中添加元素时，首先应该创建HashMap对象

HashMap的构造方法：

public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

HashMap中的一些的属性

final float loadFactor；

static final float DEFAULT_LOAD_FACTOR=0.75f;

transient Node<K,V>[]table;

transient Set<Map.Entry<K,V>> entrySet;

 transient int size;

transient int modCount;

transient Node<K,V>[]table;

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;  //用来存put的key，value值
        V value;
        Node<K,V> next; //用来标记下一个元素

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;        //构造函数
            this.next = next;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }

当我们创建一个HashMap对象时在内存中：

当向其中添加元素的时候调用put()方法

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

调用了hash()方法，传入的参数是key

 static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

当我们重写equals()方法时要重写hashCode()方法，因为key是基于hashCode()方法来处理的。     

然后进入putVal方法中：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;    
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) 
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { 
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

当放入第一个元素时，为空，执行 n = (tab = resize()).length;

调用resize()方法系统会初始化一个长度为16的Node数组。

然后

if ((p = tab[i = (n - 1) & hash]) == null)
    tab[i] = newNode(hash, key, value, null);

i = (n - 1) & hash;   //hash是传过来的，其中n是底层数组的长度，用&运算符计算出i的值 
p = tab[i];   //用计算出来的i的值作为下标从数组中元素
if(p == null){    //如果这个元素为null，用key,value构造一个Node对象放入数组下标为i的位置
     tab[i] = newNode(hash, key, value, null);    //创建新的节点并加入其中
}

经过(n - 1) & hash算出添加的位置然后就可以加入其中

如果添加的位置有元素了就执行下面这段代码

for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) 
                            treeifyBin(tab, hash);
                        break;
                    }

  if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);

也就是说new一个新的Node对象并把当前Node的next引用指向该对象，也就是说原来该位置上只有一个元素对象，现在变成单链表了

if (binCount >= TREEIFY_THRESHOLD - 1) 
      treeifyBin(tab, hash);

static final int TREEIFY_THRESHOLD=8；

这两行代码是当链表的长度达到8时，将链表转化为红黑树来处理

在我们添加对象的时候

if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);

判断该位置是否为空，此时就是用计算出来的i值作为下标从元素数组中取元素，不为空就不会执行 tab[i] = newNode(hash, key, value, null);

 if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;

这是在判断k值是否相等，如果hash值相等，key也相等，或者equals相等，p赋值给e，当我们新new出来一个key的对象时，只要满足equals相等，也视为key相等