添加方法
public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } static final int hash(Object key) {//hash函数，用于索引定位 int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); } 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;//存储数据Node没有初始化，此时初始化 if ((p = tab[i = (n - 1) & hash]) == null)//(n-1)&hash用于定位，若为null，表明Node数组该位置没有Node对象，即没有碰撞 tab[i] = newNode(hash, key, value, null);//对应位置添加Node对象 else {//表明对应位置是有Node对象的，hash碰撞了 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) // -1 for 1st//链表长度大于TREEIFY_THRESHOLD值，转换为红黑树结构 treeifyBin(tab, hash); break; } if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))//如果找到重复的key，判断该节点和要插入的元素key是否相等，如果相等，出循环 break; p = e;//为了遍历，和e = p.next结合来遍历 } } if (e != null) { // existing mapping for key//key映射的节点不为空 V oldValue = e.value;//取出节点值记录为老的节点值 if (!onlyIfAbsent || oldValue == null)//如果onlyIfAbsent为false，或者老的节点值为null，赋予新的值 e.value = value; afterNodeAccess(e);//访问后回调 return oldValue; } } ++modCount;//结构性修改记录 if (++size > threshold)//判断是否需要扩容 resize(); afterNodeInsertion(evict);//插入后回调 return null; }put流程
1.通过hash函数计算key的hash值，调用putVal方法
2.如果hash表为空，调用resize()方法创建一个hash表
3.根据hash值索引hash表对应桶位置，判断该位置是否有hash碰撞
3.1 没有碰撞，直接插入映射入hash表
3.2 有碰撞，遍历桶中节点
3.2.1 第一个节点匹配，记录该节点
3.2.2 第一个节点没有匹配，桶中结构为红黑树结构，按照红黑树结构添加数据，记录返回值
3.2.3 第一个节点没有匹配，桶中结构是链表结构。遍历链表，找到key映射节点，记录，退出循环。
没有则在链表尾部添加节点。插入后判断链表长度是否大于转换为红黑树要求，符合则转为红黑树结构
3.2.4 用于记录的值判断是否为null，不为则是需要插入的映射key在hash表中原来有，替换值，返回旧值putValue方法结束
4.结构性修改记录，判断是否需要扩容
get方法
public V get(Object key) { Node<K,V> e; return (e = getNode(hash(key), key)) == null ? null : e.value; } final Node<K,V> getNode(int hash, Object key) { Node<K,V>[] tab; Node<K,V> first, e; int n; K k; if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) {//hash表存在且长度大于0且对应的key定位的桶不为null if (first.hash == hash && // always check first node ((k = first.key) == key || (key != null && key.equals(k)))) return first;//第一个节点符合 返回第一个 if ((e = first.next) != null) {//第一个不符合，如果链表还有下一个节点 if (first instanceof TreeNode)//为红黑树结构 return ((TreeNode<K,V>)first).getTreeNode(hash, key);//按照红黑树结构查找 do {//遍历链表，查询hash 和equals相等的，有则返回，一直到链尾 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e; } while ((e = e.next) != null); } } return null; }修改方法
public V replace(K key, V value) { Node<K,V> e; if ((e = getNode(hash(key), key)) != null) {//根据key查询 有则修改 V oldValue = e.value; e.value = value; afterNodeAccess(e); return oldValue; } return null; }remove方法
public V remove(Object key) { Node<K,V> e; return (e = removeNode(hash(key), key, null, false, true)) == null ? null : e.value; } final Node<K,V> removeNode(int hash, Object key, Object value, boolean matchValue, boolean movable) { Node<K,V>[] tab; Node<K,V> p; int n, index; if ((tab = table) != null && (n = tab.length) > 0 && (p = tab[index = (n - 1) & hash]) != null) {//hash表存在且长度大于0且对应的key定位的桶不为null Node<K,V> node = null, e; K k; V v; if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) node = p;//判断第一个节点，符合记录 else if ((e = p.next) != null) {//第一个节点不符合 if (p instanceof TreeNode)//判断是否为红黑树结构 node = ((TreeNode<K,V>)p).getTreeNode(hash, key); else {//为链表结构，遍历 do { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) { node = e; break; } p = e; } while ((e = e.next) != null); } } if (node != null && (!matchValue || (v = node.value) == value || (value != null && value.equals(v)))) {//判断是否符合有要移除的node if (node instanceof TreeNode)//为红黑树结构 ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable); else if (node == p)//第一个节点就是符合的 tab[index] = node.next;//删除第一个节点(第一个节点指向null，或者指向原来第二个节点) else p.next = node.next;//链表结构，指向后面的一个节点 ++modCount; --size; afterNodeRemoval(node); return node; } } return null; } HashMap遍历
遍历HashMap键值对
根据map.entrySet()获得键值对Set集合，后续遍历
for (Map.Entry<Integer, String> entry : maps.entrySet()) { System.out.println(entry.getKey()+":"+entry.getValue()); }
遍历HashMap的键视图
根据maps.keySet()获得HashMap的键的Set集合，后续遍历
for (Integer integer : maps.keySet()) { System.out.println(integer); }
遍历HashMap的值视图
根据maps.values()获得HashMap的键的Collection集合，后续遍历
for (String value : maps.values()) { System.out.println(value); }