首先讲HashMap的一些知识：
1. Map与Collection并列存在。用于保存具有映射关系的数据：key-value；
2. Map中的 key 和 value 可以是任何引用类型的数据，会封装到HashMap$Node 对象中；
3. Map中的 key 不允许重复，原因和HashSet一样；
4. Map中的 value 可以重复；
5. Map中的 key 可以为null，value也可以为null，key为null 只能有一个，value为null可以有多个；
6. Map和HashSet一样，不保证映射的顺序，因为底层是以 hash 表的方式存储；
7. HashMap没有实现同步机制，不是线程安全的，方法没有做同步互斥的操作，没有synchronized关键字。
HashMap的能用entrySet进行遍历
1. Map的k-v 最后是 HashMap$Node node = newNode(hash, key, value, null);
2. Map的k-v 为了方便遍历，还会创建 EntrySet 集合，该集合存放的元素的类型 Entry，而一个Entry对象就有 k-v EntrySet<Entry<k,v>>
即：transient Set<Map.Entry<K,V>> entrySet;
3. entrySet中，定义的类型是Map.Entry，但实际上存放的还是 HashMap$Node
这是因为源码中的：static class Node<K,V> implements Map.Entry<K,V>
4. 当把 HashMap$Node 对象存放到 entrySet 就方便我们的遍历，因为 Map.Entry 提供了重要方法
K getKey(); V getValue();
直接上代码(省略泛型)
Map map = new HashMap<>();
map.put("no1", "666");
map.put("no2", "888");
Set set = map.entrySet();
System.out.println(set.getClass());// HashMap$EntrySet 里面存放的就是Entry<k,v> Set<Map.Entry<K, V>> entrySet()
for (Object o : set) {
System.out.println(o.getClass());// HashMap$Node
System.out.println(o);
//1. 为了从 HashMap$Node 取出k-v，先做一个向下转型
Map.Entry entry = (Map.Entry) o;
System.out.println(entry.getKey() + "==>" + entry.getValue());//Map.Entry 提供了重要方法
}
Collection values = map.values();//把 HashMap$Node 放入entrySet，entrySet里存放 Node<k,v>
System.out.println(map.keySet() + "==>" + map.keySet().getClass());// 获取所有的键
System.out.println(values + "==>" + map.values().getClass());// 获取类名
遍历的例子
public class MapTest02 {
public static void main(String[] args) {
Map map = new HashMap();
Employee employee1 = new Employee(1, 10000, "jack");
Employee employee2 = new Employee(2, 20000, "mary");
Employee employee3 = new Employee(3, 30000, "lucy");
map.put(employee1.getId(), employee1);// id作为键
map.put(employee2.getId(), employee2);
map.put(employee3.getId(), employee3);
Set entrySet = map.entrySet();
for (Object o : entrySet) {
Map.Entry entry = (Map.Entry) o;
Object value = entry.getValue();
Employee employee = (Employee) value;
if (employee.getPrice() > 18000)// 打印 price > 18000
System.out.println("key:" + entry.getKey() + "===>value:" + employee);
}
System.out.println("=====================");
Iterator iterator = entrySet.iterator();
while (iterator.hasNext()) {
Map.Entry next = (Map.Entry) iterator.next();
// 通过entry取得key和value
Employee value = ((Employee) next.getValue());
if (value.getPrice() > 18000)// 打印 price > 18000
System.out.println(value);
}
}
}
class Employee {
private int id;
private int price;
private String name;
@Override
public String toString() {
return "Employee{" +
"id=" + id +
", price=" + price +
", name='" + name + '\'' +
'}';
}
public Employee(int id, int price, String name) {
this.id = id;
this.price = price;
this.name = name;
}
public int getId() {
return id;
}
public Employee setId(int id) {
this.id = id;
return this;
}
public int getPrice() {
return price;
}
public Employee setPrice(int price) {
this.price = price;
return this;
}
public String getName() {
return name;
}
public Employee setName(String name) {
this.name = name;
return this;
}
}
HashMap底层
1. Java8中HashMap演变成：数组+链表+红黑树；
2. HashMap底层维护了Node类型的数据table，默认为null；
3. 当创建对象时，将 加载因子(loadFactor) 初始化为0.75；
4. 当添加 key-val 时，通过key的哈希值得到在 table 的索引，然后判断该索引处是否有元素，
如果没有元素直接添加，如果该索引处有元素，继续判断该元素的key和准备加入的key是否相等，
如果相等，则直接替换val；如果不相等需要判断是树结构还是链表结构，做出相应处理，
如果添加时发现容量不够，则需要扩容；
5. 第一次添加，则需要扩容 table 容量为16，临界值(threshold)为12(16*0.75)
6. 以后再扩容，则需要扩容 table 容量为原来的2倍(32)，临界值为原来的2倍，即24，依此类推。
7. 在 Java8 中，如果一条链表的元素个数超过 TREEIFY_THRESHOLD(默认8)，
并且 table 的大小 >= MIN_TREEIFY_CAPACITY(默认64)，就会进行树化(红黑树)
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
HashMap.Node<K,V>[] tab; HashMap.Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)// 第一次put 表为空，则进行扩容
n = (tab = resize()).length; // 扩容resize()后赋值给n，第一次为16
if ((p = tab[i = (n - 1) & hash]) == null)// 如果表中当前节点为null，则将值放入
tab[i] = newNode(hash, key, value, null);
else {
HashMap.Node<K,V> e; K k;
// 如果table的索引位置的key的hash相同和新的key的hash值相同，
// 并满足(table现有的结点的key和准备添加的key是同一个对象 || equals返回真) 就认为不能加入新的k-v
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 如果当前的table的已有的Node是红黑树，就按照红黑树的方式处理。
else if (p instanceof TreeNode)
e = ((HashMap.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);
// 加入后，判断当前链表个数，是否已经到达8个，到8个后
// 就调用 treeifyBin 方法进行红黑树的转换，在转换的过程中还会进行判断
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
// 如果在循环比较的过程中，发现有相同，就break；就只是替换value，直至判断加入到链表
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value; //替换，key对应的value
afterNodeAccess(e);
return oldValue;
}
}
++modCount; // 每增加一个Node，就size++
if (++size > threshold) //12-24-48-96（临界值） size(节点个数)>threshold(阈值)就扩容
resize();
afterNodeInsertion(evict);
return null;
}
关于树化(转成红黑树)
如果 table 表(数组)为 null 或者大小还没有到64，暂时不树化，而是进行扩容。
否则才会真正的树化
//方法翻译：替换给定哈希索引处 bin 中的所有链接节点，除非表太小，在这种情况下调整大小。
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)//注释：1
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null;
do {
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
注释1：如果数组(也有叫桶，叫表的说法，我这里直接简称数组)的长度 < 64，以避免调整大小和树化阈值之间的冲突，再次进行扩容。
关于树化之后的内容我会再次补充，暂时就到这。
以上这些内容我是根据韩顺平老师学的，本人第一次学习HashMap底层及其一些应用语法，想把自己觉得好的东西记录下来，有什么不好的地方，大神们可以指点以下。谢谢
2129
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
