正文
java 基础知识（四）
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
自己写一个简单的Map
清浅池塘
程序员，专栏：Java那些事儿唯一作者，咨询前请先点详细资料
130 人赞同了该文章
许多许多年以前，在自学Java的时候，笔者曾经写过一个简单的Map，当年很有成就感，拿出来博大家一笑。
Map的实现其实很简单，一个key对应一个value就行
定义一个MyMap类
声明一个Node数组用来存放元素，一个size来记录Map的逻辑长度，看一下Node类，Node类位于MyMap类的内部
该类为内部静态类，只能在MyMap类里访问，定义了一个key，一个value用于存放元素内容。
提供put方法
上图中的indexOfKey方法
提供get方法
size方法
以下是测试代码
测试结果
debug来看一下
最后来画一下MyMap对象在堆内存中的图
在这个MyMap中，放入元素，获取元素，都会去调用indexOfKey方法遍历底层数组，put和get的时间复杂度用大O表示法是O(n)，在map元素不多的情况下，凑合着还能用，当map元素过多时，效率下降得非常厉害。
注：1、该示例为了追求简单，并没有实现Map接口，只是简单的写了三个方法，put，get，size，如果要满足JDK中Map的规范，需要实现Map接口，并实现里面的所有方法。2、本示例中，没有考虑到底层数组的扩容，当往里添加10个以上的元素时，会抛出java.lang.ArrayIndexOutOfBoundsException异常（数组下标越界异常），有兴趣的朋友可自行扩展。3、本Map是笔者写着玩的，是想告诉初学者我们也可以写一个简单的Map来自己用，JDK中的HashMap，TreeMap等的实现和这完全不同，切勿对号入座。
下篇文章我们将介绍HashMap的底层实现，看看人家是怎么把性能发挥到极致的。
HashMap底层实现原理（上）
清浅池塘
程序员，专栏：Java那些事儿唯一作者，咨询前请先点详细资料
486 人赞同了该文章
修改记录：
2017年8月17日 12：00 调整了本文顺序，新增小结。
本来想先在专栏里简单的说一下二叉树，红黑树的内容后再说HashMap的，但看到评论区里不断的出现HashMap这个词，怕大家等得着急，本篇文章就先说说HashMap吧，前面讲ArrayList和LinkedList时把源码说得很细，只要理解了这两块内容，本篇内容也很好理解，先来看看HashMap在Map这个大家族中的位置。
上图中，白色部分是接口，黄色部分是要重点了解的，最好是看一遍源码，绿色部分已经过时，不常用了，但是面试中可能会问到。这里先简单的说一下这几个Map，TreeMap是基于树的实现，HashMap，HashTable，ConcurrentHashMap是基于hash表的实现，下文我们会介绍hash表。HashTable和HashMap在代码实现上，基本上是一样的，和Vector与Arraylist的区别大体上差不多，一个是线程安全的，一个非线程安全，忘记了的朋友可以去看这篇文章，传送门：Arraylist与Vector的区别。ConcurrentHashMap也是线程安全的，但性能比HashTable好很多，HashTable是锁整个Map对象，而ConcurrentHashMap是锁Map的部分结构，LinkedHashMap后续会单独开文讲解。
Map其实很简单，就是一个key，对应一个value。本章我们重点了解HashMap，话不多说，上代码：
执行构造函数，当我们看到这个new，第一反应应该是这货又在堆内存里开辟了一块空间。
构造函数如下：
似乎简单，就是初始化了一个负载因子
负载因子默认为0.75f，这个负载因子后续会详说。
嘿嘿，又看到了传说中的数组，数组里原对象是Node，来看一下Node是什么鬼
其实很简单，一些属性，一个key，一个value，用来保存我们往Map里放入的数据，next用来标记Node节点的下一个元素。目前还没有任何代码用到Node，我们只能从成员变量入手了
这两个就不多说了吧，一个是逻辑长度，一个是修改次数，ArrayList，LinkedList也有这两个属性，老规矩，我们来画一画
HashMap我们就初始化好了，成员变量table数组默认为null，size默认为0，负载因子为0.75f，初始化完成，往里添加元素，来看一下put的源码
就一行代码，调用了putVal方法，其中key是传进来的“张三”这个字符串对象，value是“张三”这个Person对象，调用了一个方法hash()，再看一下
看到了熟悉的hashCode，我们在前面的文章里已经强调过很多次了，重写equals方法的时候，一定要重写hashCode方法，因为key是基于hashCode来处理的。继续看putVal方法
resize方法比较复杂，这儿就不完全贴出来了，当放入第一个元素时，会触发resize方法的以下关键代码
再看这个DEFAULT_INITIAL_CAPACITY是什么东东
又是传说中的移位运算符，1 << 4 其实就是相当于16。
恩，这句是关键，当我们放入第一个元素时，如果底层数组还是null，系统会初始化一个长度为16的Node数组，像极了ArrayList的初始化。
最后返回new出来的数组，继续画图，由于篇幅有限，下图中省略了部分数组内容，注意，虽然数组长度为16，但逻辑长度size依然是0
继续执行下图中putVal方法里的红框内容
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);
}
这个hash值是字符串“张三”这个对象的hashCode方法与hashMap提供hash()方法共同计算出来的结果，其中n是数组的长度，目前数组长度为16，不管这个hash的值是多少，经过(n - 1) & hash计算出来的i 的值一定在n-1之间。刚好是底层数组的合法下标，用i这个下标值去底层数组里去取值，如果为null，创建一个Node放到数组下标为i的位置。这里的“张三”计算出来的i的值为2，继续画图
继续添加元素“李四”，“王五”，“赵六”，一切正常，key：“李四”经过(n - 1) & hash算出来在数组下标位置为1，“王五”为7，“赵六”为9，添加完成后如下图
上图更趋近于堆内存中的样子，但看起来比较复杂，我们简化一下
上图是简化后的堆内存图。继续往里添加“孙七”，通过(n - 1) & hash计算“孙七”这个key时计算出来的下标值是1，而数组下标1这个位置目前已经被“李四”给占了，产生了冲突。相信大家在看本文的过程中也有这样的疑惑，万一计算出来的下标值i重了怎么办？我们来看一看HashMap是怎么解决冲突的。
上图中红框里就是冲突的处理，这一句是关键
p.next = newNode(hash, key, value, null);
也就是说new一个新的Node对象并把当前Node的next引用指向该对象，也就是说原来该位置上只有一个元素对象，现在转成了单向链表，继续画图
继续添加其它元素，添加完成后如下
到这里，我们的元素就添加完了。我们debug看一下
大框里的内容是链表的体现，小框里的内容是单元素的体现。
红框中还有两行比较重要的代码
if (binCount >= TREEIFY_THRESHOLD - 1) //当binCount>=TREEIFY_THRESHOLD-1
treeifyBin(tab, hash);//把链表转化为红黑树
再看看TREEIFY_THRESHOLD的值
当链表长度到8时，将链表转化为红黑树来处理，由于树相关的内容本专栏还未讲解，红黑树的内容这里就不深入了。树在内存中的样子我们还是画个图简单的了解一下
在JDK1.7及以前的版本中，HashMap里是没有红黑树的实现的，在JDK1.8中加入了红黑树是为了防止哈希表碰撞攻击，当链表链长度为8时，及时转成红黑树，提高map的效率。在面试过程中，能说出这一点，面试官会对你加分不少。
注：本章所讲的移位运算符（如：“<<”）、位运算符（如：“&”），红黑树、哈希表碰撞攻击等，这里不做详解，大家有兴趣的话请在评论区留言，响应的人多的话，会单独开文讲解。
思考下面代码：
hash方法的实现：
在put放入元素时，HashMap又自己写了一个hash方法来计算hash值，大家想想看，为什么不用key本身的hashCode方法，而是又处理了一下？
本文到这里先告一个段落，先做一个小结。
HashMap的最底层是数组来实现的，数组里的元素可能为null，也有可能是单个对象，还有可能是单向链表或是红黑树。
文中的resize在底层数组为null的时候会初始化一个数组，不为null的情况下会去扩容底层数组，并会重排底层数组里的元素。
如果喜欢本系列文章，请为我点赞或顺手分享，您的支持是我继续下去的动力，您也可以在评论区留言想了解的内容，有机会本专栏会做讲解，最后别忘了关注一下我。
HashMap底层实现原理（下）
清浅池塘
程序员，专栏：Java那些事儿唯一作者，咨询前请先点详细资料
197 人赞同了该文章
公众号：saysayJava，敬请支持。
上一篇文章我们介绍了HashMap的底层实现，但还遗留了一点内容，我们再回顾一下上一篇文章里说的内容
执行完红框里的代码，personMap里放入了8个元素，放置完成后在堆内存表现如下图
如果忽略底层实现细节，是这样的
在Map中，一个key，对应了一个value，如果key的值已经存在，Map会直接替换value的内容，来看一下源码中是怎么实现的，来看以下代码
Person oldPerson1 = personMap.put("张三", new Person("新张三", 21));
Person oldPerson2 = personMap.put("孙七", new Person("新孙七", 32));
System.out.println("oldPerson1.getName() ：" + oldPerson1.getName());
System.out.println("oldPerson2.getName() : " + oldPerson2.getName());
System.out.println("personMap.size() : " + personMap.size());
new了一个Person“新张三”，注意，key依然是张三，看一下源码
放入“新张三”时，会执行以上代码1、2、5
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){//这儿P不为null，所以下面这行代码不会执行。
tab[i] = newNode(hash, key, value, null);//这行代码不会执行
}
很简单，直接在底层数组里取值赋值给p，由于p不为null，执行else里的逻辑
Node<K,V> e; K k;
if (p.hash == hash && //如果hash值相等，key也相等，或者equals相等，赋值给e
((k = p.key) == key || (key != null && key.equals(k))))
e = p;//赋值给e
又看到了熟悉的equals方法，这里我们hash值相等，key的值也相等，条件成立，把值赋值给e。（如果key的值不相等，就比较equals方法，也就是说，就算key是一个新new出来的对象，只要满足equals，也视为key相同）
if (e != null) { // existing mapping for key
V oldValue = e.value;//定义一个变量来存旧值
if (!onlyIfAbsent || oldValue == null)
e.value = value;//把value的值赋值为新的值
afterNodeAccess(e);
return oldValue;//返回的值
}
这段代码就比较简单了，用新的value替换旧value并返回旧的value。画一下图
再new一个Person“新孙七”并put到personMap中，注意，key依然是“孙七”，会执行图17-2里的1、2、3、4、5，由于2、3不满足条件，实际执行的是1、4、5，1这一步已经说过了，重点说一下4这一步
for (int binCount = 0; ; ++binCount) {//循环
if ((e = p.next) == null) {//如果循环到最后也没找到，把元素放到最后
p.next = newNode(hash, key, value, null);//把元素放到最后
if (binCount >= TREEIFY_THRESHOLD - 1) //如果长度超>=8，转换成红黑树
treeifyBin(tab, hash);//转换成红黑树
break;
}
if (e.hash == hash && //这段代码和第2步一样
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;//如果hash值相等，key也相等或者equals相等，赋值给e
}
}
}
其实就是循环链表的节点，直到找到"孙七"这个key，然后执行图17-2里的第5步，如果找不到，就添加到最后，这里我们key是“孙七”，在链表中找到元素替换value即可，再画一下图
最后来看看放到树里的方法putTreeVal，由于树的内容我们还没涉及到，下面只标注出了关键代码
和链表类似，循环（遍历）树的节点，如果找到节点，返回节点，执行图17-2里的第5步更新value。如果循环完整颗数都找不到相应的key，添加新节点。
最后我们看一下本文初那段示例代码的执行结果：
虽然元素已经替换成新的值，但示例中打印的是替换前的值，元素个数还是8不变，debug看一下，是不是value更新成功了
更新已经成功。
结合上一篇内容，做一个总结，在hashMap中放入（put）元素，有以下重要步骤：
1、计算key的hash值，算出元素在底层数组中的下标位置。
2、通过下标位置定位到底层数组里的元素（也有可能是链表也有可能是树）。
3、取到元素，判断放入元素的key是否==或equals当前位置的key，成立则替换value值，返回旧值。
4、如果是树，循环树中的节点，判断放入元素的key是否==或equals节点的key，成立则替换树里的value，并返回旧值，不成立就添加到树里。
5、否则就顺着元素的链表结构循环节点，判断放入元素的key是否==或equals节点的key，成立则替换链表里value，并返回旧值，找不到就添加到链表的最后。
精简一下，判断放入HashMap中的元素要不要替换当前节点的元素，key满足以下两个条件即可替换：
1、hash值相等。
2、==或equals的结果为true。
由于hash算法依赖于对象本身的hashCode方法，所以对于HashMap里的元素来说，hashCode方法与equals方法非常的重要，这也是在说说Java里的equals（中）一文中强调重写对象的equals方法一定要重写hashCode方法的原因，不重写的话，放到HashMap中可能会得不到你想要的结果！本示例中放入的key是String类型的，String这个类已经重写了hashCode方法，有兴趣的朋友可以自行查看源码。
如果喜欢本系列文章，请为我点赞或顺手分享，您的支持是我继续下去的动力，您也可以在评论区留言想了解的内容，有机会本专栏会做讲解，最后别忘了关注一下我。
HashSet的秘密
清浅池塘
程序员，专栏：Java那些事儿唯一作者，咨询前请先点详细资料
153 人赞同了该文章
HashMap还没讲完，还有几篇文章，目前在构思中，HashMap是集合类的精华，底层实现也比较复杂，真正理解了HashMap，也算是上了小小的一层台阶。
这篇文章我们先轻松一下，不讲HashMap，来说说HashSet。如果有点Java基础的童鞋，应该都知道List和Set都实现自Collection，List保证元素的添加顺序，元素可重复。而Set不保证元素的添加顺序，元素不可重复
先来看看Set家族在Collection中的位置，红框里的内容就是Set的大家族了，Set接口继承自Collection。有两个很重要的实现HashSet和TreeSet。其中黄色部分前面已经说过了是要重点了解的，老规矩，上代码，大家可以先想一想以下代码的执行结果。
public static void main(String[] args){
Set<String> strSet = new HashSet<>();//new了一个HashSet
strSet.add("张三");
strSet.add("李四");
strSet.add("王五");
strSet.add("赵六");
System.out.println("strSet : " + strSet);
System.out.println("strSet.size() : " + strSet.size());
System.out.println("strSet里是否为空 : " + strSet.isEmpty());
System.out.println("删除王五。。。。");
boolean delFlag = strSet.remove("王五");
System.out.println("删除王五是否成功" + delFlag);
System.out.println("删除王五后的strSet : " + strSet);
System.out.println("strSet中是否包含王五：" + strSet.contains("王五"));
System.out.println("strSet中是否包含张三：" + strSet.contains("张三"));
System.out.println("clear清除元素...");
strSet.clear();
System.out.println("clear清除元素后的strSet : " + strSet);
System.out.println("strSet长度 : " + strSet.size());
System.out.println("strSet里是否为空 : " + strSet.isEmpty());
}
先来看第一行代码：
Set<String> strSet = new HashSet<>();//new了一个HashSet
new了一个HashSet，前面的文章已经说过很多次了，只要是看到new，这货肯定在堆内存里开辟了一块空间，先找到HashSet的构造函数看看，看到如下代码：
等等，怎么出现了HashMap，这个HashMap到底是什么鬼？再看一下map，追踪一下
就是一个HashMap，老规矩画图吧
HashMap的初始化在HashMap底层实现原理（上）一文中已经说过了，这里就不再详解了，需要了解的朋友请自行回顾。继续执行以下代码，往strSet添加元素"张三"
strSet.add("张三");
再看add方法
上面红框里的这行代码和等同于
boolean putFlag = map.put(e,PRESENT);
return putFlag;
原来就是调用底层HashMap的put方法，把"张三"作为key，PRESENT作为value放在hashMap里，讲HashMap的时候讲过了，如果put时key重了，会返回被覆盖的value值（oldValue），否则返回null，这儿的HashSet又给包装了一下，如果key没有重（oldValue == null），就返回true，否则返回false。继续看这个PRESENT是什么鬼
很简单就是new了一个Object，继续画图
调用底层HashMap的时候，key是传进去的“张三”，value是PRESENT，也就是一个Object对象，继续往里添加“李四”，“王五”，“赵六”
strSet.add("李四");
strSet.add("王五");
strSet.add("赵六");
依次放入“李四”，“王五”，“赵六”，value都是一样的，为PRESENT，继续画图
所有元素的value都指向Object对象，HashSet虽然底层是用HashMap来实现的，但由于用不到HashMap的value，所以不会为底层HashMap的每个value分配一个内存空间，因此并不会过多的占用内存，请放心使用。
再来看看示例代码里的size()、isEmpty()、remove()、contains()、clear()等方法的实现
调用的是底层HashMap的size方法
调用的是底层HashMap的isEmpty方法
调用的是底层HashMap的remove方法
调用的是底层HashMap的contains方法
调用的是HashMap的clear方法。
这些方法基本上没什么逻辑代码，就是复用了HashMap里的方法而已。HashSet就是利用HashMap来实现的。这时候我们大胆的猜测一下，TreeSet是不是也是用TreeMap来实现的呢？迫不及待打开TreeSet的源码
构造函数this调了另一个构造函数
再来看m
这个m是NavigableMap类型的，NavigableMap只是一个接口而已
再来看TreeMap，实现了NavigableMap这个接口
绕了好大一个圈，其实就是相当于
NavigableMap m = new TreeMap<>();
也就是说，TreeSet底层实现也是利用TreeMap来实现的，再来看看TreeSet的其它方法
调用的是底层TreeMap的size方法
调用的是底层TreeMap的isEmpty方法
TreeMap的add方法是调用底层TreeMap的put方法，只是改了个名字而已
其它方法大致上也是如此，就不一一举例说明了，感兴趣的朋友请自行阅读源码。
最后，执行一下本文开始那段示例代码的执行结果
注：本文示例代码，已上传至公众号：saysayJava，需要练习的朋友请自行下载。
小结：HashSet底层声明了一个HashMap，HashSet做了一层包装，操作HashSet里的元素时其实是在操作HashMap里的元素。TreeSet底层也是声明了一个TreeMap，操作TreeSet里的元素其实是操作TreeMap里的元素。
本文刚一上线就收到了大量评论，评论区里有人说TreeSet和LinkedHashSet是有序的，这里强调一下，我们指的Set不保证插入有序是指Set这个接口的规范，实现类只要遵循这个规范即可，当然也可以写有序的版本出来，比如LinkedHashSet。而TreeSet是里面的内容有序（按照一定规则排序），但不是指元素的添加顺序。
注意：大家在写TreeSet测试本文代码的时候，可能刚好得到张三，李四，王五、赵六这样的顺序，这是碰巧，请大家打乱顺序测试。
最后：感谢
@程序猎人
一直以来对本专栏的勘误工作。感谢
@阿法利亚
经过他在评论区提出的质疑，本文修正并补充了一些地方，减少读者一些理解上的歧义。
清浅池塘
程序员，专栏：Java那些事儿唯一作者，咨询前请先点详细资料
许多许多年以前，在自学Java的时候，笔者曾经写过一个简单的Map，当年很有成就感，拿出来博大家一笑。
Map的实现其实很简单，一个key对应一个value就行
定义一个MyMap类
声明一个Node数组用来存放元素，一个size来记录Map的逻辑长度，看一下Node类，Node类位于MyMap类的内部
该类为内部静态类，只能在MyMap类里访问，定义了一个key，一个value用于存放元素内容。
提供put方法
上图中的indexOfKey方法
提供get方法
size方法
以下是测试代码
测试结果
debug来看一下
最后来画一下MyMap对象在堆内存中的图
在这个MyMap中，放入元素，获取元素，都会去调用indexOfKey方法遍历底层数组，put和get的时间复杂度用大O表示法是O(n)，在map元素不多的情况下，凑合着还能用，当map元素过多时，效率下降得非常厉害。
注：1、该示例为了追求简单，并没有实现Map接口，只是简单的写了三个方法，put，get，size，如果要满足JDK中Map的规范，需要实现Map接口，并实现里面的所有方法。2、本示例中，没有考虑到底层数组的扩容，当往里添加10个以上的元素时，会抛出java.lang.ArrayIndexOutOfBoundsException异常（数组下标越界异常），有兴趣的朋友可自行扩展。3、本Map是笔者写着玩的，是想告诉初学者我们也可以写一个简单的Map来自己用，JDK中的HashMap，TreeMap等的实现和这完全不同，切勿对号入座。
下篇文章我们将介绍HashMap的底层实现，看看人家是怎么把性能发挥到极致的。
HashMap底层实现原理（上）
清浅池塘
程序员，专栏：Java那些事儿唯一作者，咨询前请先点详细资料
486 人赞同了该文章
修改记录：
2017年8月17日 12：00 调整了本文顺序，新增小结。
本来想先在专栏里简单的说一下二叉树，红黑树的内容后再说HashMap的，但看到评论区里不断的出现HashMap这个词，怕大家等得着急，本篇文章就先说说HashMap吧，前面讲ArrayList和LinkedList时把源码说得很细，只要理解了这两块内容，本篇内容也很好理解，先来看看HashMap在Map这个大家族中的位置。
上图中，白色部分是接口，黄色部分是要重点了解的，最好是看一遍源码，绿色部分已经过时，不常用了，但是面试中可能会问到。这里先简单的说一下这几个Map，TreeMap是基于树的实现，HashMap，HashTable，ConcurrentHashMap是基于hash表的实现，下文我们会介绍hash表。HashTable和HashMap在代码实现上，基本上是一样的，和Vector与Arraylist的区别大体上差不多，一个是线程安全的，一个非线程安全，忘记了的朋友可以去看这篇文章，传送门：Arraylist与Vector的区别。ConcurrentHashMap也是线程安全的，但性能比HashTable好很多，HashTable是锁整个Map对象，而ConcurrentHashMap是锁Map的部分结构，LinkedHashMap后续会单独开文讲解。
Map其实很简单，就是一个key，对应一个value。本章我们重点了解HashMap，话不多说，上代码：
执行构造函数，当我们看到这个new，第一反应应该是这货又在堆内存里开辟了一块空间。
构造函数如下：
似乎简单，就是初始化了一个负载因子
负载因子默认为0.75f，这个负载因子后续会详说。
嘿嘿，又看到了传说中的数组，数组里原对象是Node，来看一下Node是什么鬼
其实很简单，一些属性，一个key，一个value，用来保存我们往Map里放入的数据，next用来标记Node节点的下一个元素。目前还没有任何代码用到Node，我们只能从成员变量入手了
这两个就不多说了吧，一个是逻辑长度，一个是修改次数，ArrayList，LinkedList也有这两个属性，老规矩，我们来画一画
HashMap我们就初始化好了，成员变量table数组默认为null，size默认为0，负载因子为0.75f，初始化完成，往里添加元素，来看一下put的源码
就一行代码，调用了putVal方法，其中key是传进来的“张三”这个字符串对象，value是“张三”这个Person对象，调用了一个方法hash()，再看一下
看到了熟悉的hashCode，我们在前面的文章里已经强调过很多次了，重写equals方法的时候，一定要重写hashCode方法，因为key是基于hashCode来处理的。继续看putVal方法
resize方法比较复杂，这儿就不完全贴出来了，当放入第一个元素时，会触发resize方法的以下关键代码
再看这个DEFAULT_INITIAL_CAPACITY是什么东东
又是传说中的移位运算符，1 << 4 其实就是相当于16。
恩，这句是关键，当我们放入第一个元素时，如果底层数组还是null，系统会初始化一个长度为16的Node数组，像极了ArrayList的初始化。
最后返回new出来的数组，继续画图，由于篇幅有限，下图中省略了部分数组内容，注意，虽然数组长度为16，但逻辑长度size依然是0
继续执行下图中putVal方法里的红框内容
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);
}
这个hash值是字符串“张三”这个对象的hashCode方法与hashMap提供hash()方法共同计算出来的结果，其中n是数组的长度，目前数组长度为16，不管这个hash的值是多少，经过(n - 1) & hash计算出来的i 的值一定在n-1之间。刚好是底层数组的合法下标，用i这个下标值去底层数组里去取值，如果为null，创建一个Node放到数组下标为i的位置。这里的“张三”计算出来的i的值为2，继续画图
继续添加元素“李四”，“王五”，“赵六”，一切正常，key：“李四”经过(n - 1) & hash算出来在数组下标位置为1，“王五”为7，“赵六”为9，添加完成后如下图
上图更趋近于堆内存中的样子，但看起来比较复杂，我们简化一下
上图是简化后的堆内存图。继续往里添加“孙七”，通过(n - 1) & hash计算“孙七”这个key时计算出来的下标值是1，而数组下标1这个位置目前已经被“李四”给占了，产生了冲突。相信大家在看本文的过程中也有这样的疑惑，万一计算出来的下标值i重了怎么办？我们来看一看HashMap是怎么解决冲突的。
上图中红框里就是冲突的处理，这一句是关键
p.next = newNode(hash, key, value, null);
也就是说new一个新的Node对象并把当前Node的next引用指向该对象，也就是说原来该位置上只有一个元素对象，现在转成了单向链表，继续画图
继续添加其它元素，添加完成后如下
到这里，我们的元素就添加完了。我们debug看一下
大框里的内容是链表的体现，小框里的内容是单元素的体现。
红框中还有两行比较重要的代码
if (binCount >= TREEIFY_THRESHOLD - 1) //当binCount>=TREEIFY_THRESHOLD-1
treeifyBin(tab, hash);//把链表转化为红黑树
再看看TREEIFY_THRESHOLD的值
当链表长度到8时，将链表转化为红黑树来处理，由于树相关的内容本专栏还未讲解，红黑树的内容这里就不深入了。树在内存中的样子我们还是画个图简单的了解一下
在JDK1.7及以前的版本中，HashMap里是没有红黑树的实现的，在JDK1.8中加入了红黑树是为了防止哈希表碰撞攻击，当链表链长度为8时，及时转成红黑树，提高map的效率。在面试过程中，能说出这一点，面试官会对你加分不少。
注：本章所讲的移位运算符（如：“<<”）、位运算符（如：“&”），红黑树、哈希表碰撞攻击等，这里不做详解，大家有兴趣的话请在评论区留言，响应的人多的话，会单独开文讲解。
思考下面代码：
hash方法的实现：
在put放入元素时，HashMap又自己写了一个hash方法来计算hash值，大家想想看，为什么不用key本身的hashCode方法，而是又处理了一下？
本文到这里先告一个段落，先做一个小结。
HashMap的最底层是数组来实现的，数组里的元素可能为null，也有可能是单个对象，还有可能是单向链表或是红黑树。
文中的resize在底层数组为null的时候会初始化一个数组，不为null的情况下会去扩容底层数组，并会重排底层数组里的元素。
如果喜欢本系列文章，请为我点赞或顺手分享，您的支持是我继续下去的动力，您也可以在评论区留言想了解的内容，有机会本专栏会做讲解，最后别忘了关注一下我。
HashMap底层实现原理（下）
清浅池塘
程序员，专栏：Java那些事儿唯一作者，咨询前请先点详细资料
197 人赞同了该文章
公众号：saysayJava，敬请支持。
上一篇文章我们介绍了HashMap的底层实现，但还遗留了一点内容，我们再回顾一下上一篇文章里说的内容
执行完红框里的代码，personMap里放入了8个元素，放置完成后在堆内存表现如下图
如果忽略底层实现细节，是这样的
在Map中，一个key，对应了一个value，如果key的值已经存在，Map会直接替换value的内容，来看一下源码中是怎么实现的，来看以下代码
Person oldPerson1 = personMap.put("张三", new Person("新张三", 21));
Person oldPerson2 = personMap.put("孙七", new Person("新孙七", 32));
System.out.println("oldPerson1.getName() ：" + oldPerson1.getName());
System.out.println("oldPerson2.getName() : " + oldPerson2.getName());
System.out.println("personMap.size() : " + personMap.size());
new了一个Person“新张三”，注意，key依然是张三，看一下源码
放入“新张三”时，会执行以上代码1、2、5
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){//这儿P不为null，所以下面这行代码不会执行。
tab[i] = newNode(hash, key, value, null);//这行代码不会执行
}
很简单，直接在底层数组里取值赋值给p，由于p不为null，执行else里的逻辑
Node<K,V> e; K k;
if (p.hash == hash && //如果hash值相等，key也相等，或者equals相等，赋值给e
((k = p.key) == key || (key != null && key.equals(k))))
e = p;//赋值给e
又看到了熟悉的equals方法，这里我们hash值相等，key的值也相等，条件成立，把值赋值给e。（如果key的值不相等，就比较equals方法，也就是说，就算key是一个新new出来的对象，只要满足equals，也视为key相同）
if (e != null) { // existing mapping for key
V oldValue = e.value;//定义一个变量来存旧值
if (!onlyIfAbsent || oldValue == null)
e.value = value;//把value的值赋值为新的值
afterNodeAccess(e);
return oldValue;//返回的值
}
这段代码就比较简单了，用新的value替换旧value并返回旧的value。画一下图
再new一个Person“新孙七”并put到personMap中，注意，key依然是“孙七”，会执行图17-2里的1、2、3、4、5，由于2、3不满足条件，实际执行的是1、4、5，1这一步已经说过了，重点说一下4这一步
for (int binCount = 0; ; ++binCount) {//循环
if ((e = p.next) == null) {//如果循环到最后也没找到，把元素放到最后
p.next = newNode(hash, key, value, null);//把元素放到最后
if (binCount >= TREEIFY_THRESHOLD - 1) //如果长度超>=8，转换成红黑树
treeifyBin(tab, hash);//转换成红黑树
break;
}
if (e.hash == hash && //这段代码和第2步一样
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;//如果hash值相等，key也相等或者equals相等，赋值给e
}
}
}
其实就是循环链表的节点，直到找到"孙七"这个key，然后执行图17-2里的第5步，如果找不到，就添加到最后，这里我们key是“孙七”，在链表中找到元素替换value即可，再画一下图
最后来看看放到树里的方法putTreeVal，由于树的内容我们还没涉及到，下面只标注出了关键代码
和链表类似，循环（遍历）树的节点，如果找到节点，返回节点，执行图17-2里的第5步更新value。如果循环完整颗数都找不到相应的key，添加新节点。
最后我们看一下本文初那段示例代码的执行结果：
虽然元素已经替换成新的值，但示例中打印的是替换前的值，元素个数还是8不变，debug看一下，是不是value更新成功了
更新已经成功。
结合上一篇内容，做一个总结，在hashMap中放入（put）元素，有以下重要步骤：
1、计算key的hash值，算出元素在底层数组中的下标位置。
2、通过下标位置定位到底层数组里的元素（也有可能是链表也有可能是树）。
3、取到元素，判断放入元素的key是否==或equals当前位置的key，成立则替换value值，返回旧值。
4、如果是树，循环树中的节点，判断放入元素的key是否==或equals节点的key，成立则替换树里的value，并返回旧值，不成立就添加到树里。
5、否则就顺着元素的链表结构循环节点，判断放入元素的key是否==或equals节点的key，成立则替换链表里value，并返回旧值，找不到就添加到链表的最后。
精简一下，判断放入HashMap中的元素要不要替换当前节点的元素，key满足以下两个条件即可替换：
1、hash值相等。
2、==或equals的结果为true。
由于hash算法依赖于对象本身的hashCode方法，所以对于HashMap里的元素来说，hashCode方法与equals方法非常的重要，这也是在说说Java里的equals（中）一文中强调重写对象的equals方法一定要重写hashCode方法的原因，不重写的话，放到HashMap中可能会得不到你想要的结果！本示例中放入的key是String类型的，String这个类已经重写了hashCode方法，有兴趣的朋友可以自行查看源码。
如果喜欢本系列文章，请为我点赞或顺手分享，您的支持是我继续下去的动力，您也可以在评论区留言想了解的内容，有机会本专栏会做讲解，最后别忘了关注一下我。
HashSet的秘密
清浅池塘
程序员，专栏：Java那些事儿唯一作者，咨询前请先点详细资料
153 人赞同了该文章
HashMap还没讲完，还有几篇文章，目前在构思中，HashMap是集合类的精华，底层实现也比较复杂，真正理解了HashMap，也算是上了小小的一层台阶。
这篇文章我们先轻松一下，不讲HashMap，来说说HashSet。如果有点Java基础的童鞋，应该都知道List和Set都实现自Collection，List保证元素的添加顺序，元素可重复。而Set不保证元素的添加顺序，元素不可重复
先来看看Set家族在Collection中的位置，红框里的内容就是Set的大家族了，Set接口继承自Collection。有两个很重要的实现HashSet和TreeSet。其中黄色部分前面已经说过了是要重点了解的，老规矩，上代码，大家可以先想一想以下代码的执行结果。
public static void main(String[] args){
Set<String> strSet = new HashSet<>();//new了一个HashSet
strSet.add("张三");
strSet.add("李四");
strSet.add("王五");
strSet.add("赵六");
System.out.println("strSet : " + strSet);
System.out.println("strSet.size() : " + strSet.size());
System.out.println("strSet里是否为空 : " + strSet.isEmpty());
System.out.println("删除王五。。。。");
boolean delFlag = strSet.remove("王五");
System.out.println("删除王五是否成功" + delFlag);
System.out.println("删除王五后的strSet : " + strSet);
System.out.println("strSet中是否包含王五：" + strSet.contains("王五"));
System.out.println("strSet中是否包含张三：" + strSet.contains("张三"));
System.out.println("clear清除元素...");
strSet.clear();
System.out.println("clear清除元素后的strSet : " + strSet);
System.out.println("strSet长度 : " + strSet.size());
System.out.println("strSet里是否为空 : " + strSet.isEmpty());
}
先来看第一行代码：
Set<String> strSet = new HashSet<>();//new了一个HashSet
new了一个HashSet，前面的文章已经说过很多次了，只要是看到new，这货肯定在堆内存里开辟了一块空间，先找到HashSet的构造函数看看，看到如下代码：
等等，怎么出现了HashMap，这个HashMap到底是什么鬼？再看一下map，追踪一下
就是一个HashMap，老规矩画图吧
HashMap的初始化在HashMap底层实现原理（上）一文中已经说过了，这里就不再详解了，需要了解的朋友请自行回顾。继续执行以下代码，往strSet添加元素"张三"
strSet.add("张三");
再看add方法
上面红框里的这行代码和等同于
boolean putFlag = map.put(e,PRESENT);
return putFlag;
原来就是调用底层HashMap的put方法，把"张三"作为key，PRESENT作为value放在hashMap里，讲HashMap的时候讲过了，如果put时key重了，会返回被覆盖的value值（oldValue），否则返回null，这儿的HashSet又给包装了一下，如果key没有重（oldValue == null），就返回true，否则返回false。继续看这个PRESENT是什么鬼
很简单就是new了一个Object，继续画图
调用底层HashMap的时候，key是传进去的“张三”，value是PRESENT，也就是一个Object对象，继续往里添加“李四”，“王五”，“赵六”
strSet.add("李四");
strSet.add("王五");
strSet.add("赵六");
依次放入“李四”，“王五”，“赵六”，value都是一样的，为PRESENT，继续画图
所有元素的value都指向Object对象，HashSet虽然底层是用HashMap来实现的，但由于用不到HashMap的value，所以不会为底层HashMap的每个value分配一个内存空间，因此并不会过多的占用内存，请放心使用。
再来看看示例代码里的size()、isEmpty()、remove()、contains()、clear()等方法的实现
调用的是底层HashMap的size方法
调用的是底层HashMap的isEmpty方法
调用的是底层HashMap的remove方法
调用的是底层HashMap的contains方法
调用的是HashMap的clear方法。
这些方法基本上没什么逻辑代码，就是复用了HashMap里的方法而已。HashSet就是利用HashMap来实现的。这时候我们大胆的猜测一下，TreeSet是不是也是用TreeMap来实现的呢？迫不及待打开TreeSet的源码
构造函数this调了另一个构造函数
再来看m
这个m是NavigableMap类型的，NavigableMap只是一个接口而已
再来看TreeMap，实现了NavigableMap这个接口
绕了好大一个圈，其实就是相当于
NavigableMap m = new TreeMap<>();
也就是说，TreeSet底层实现也是利用TreeMap来实现的，再来看看TreeSet的其它方法
调用的是底层TreeMap的size方法
调用的是底层TreeMap的isEmpty方法
TreeMap的add方法是调用底层TreeMap的put方法，只是改了个名字而已
其它方法大致上也是如此，就不一一举例说明了，感兴趣的朋友请自行阅读源码。
最后，执行一下本文开始那段示例代码的执行结果
注：本文示例代码，已上传至公众号：saysayJava，需要练习的朋友请自行下载。
小结：HashSet底层声明了一个HashMap，HashSet做了一层包装，操作HashSet里的元素时其实是在操作HashMap里的元素。TreeSet底层也是声明了一个TreeMap，操作TreeSet里的元素其实是操作TreeMap里的元素。
本文刚一上线就收到了大量评论，评论区里有人说TreeSet和LinkedHashSet是有序的，这里强调一下，我们指的Set不保证插入有序是指Set这个接口的规范，实现类只要遵循这个规范即可，当然也可以写有序的版本出来，比如LinkedHashSet。而TreeSet是里面的内容有序（按照一定规则排序），但不是指元素的添加顺序。
注意：大家在写TreeSet测试本文代码的时候，可能刚好得到张三，李四，王五、赵六这样的顺序，这是碰巧，请大家打乱顺序测试。
最后：感谢
@程序猎人
一直以来对本专栏的勘误工作。感谢
@阿法利亚
经过他在评论区提出的质疑，本文修正并补充了一些地方，减少读者一些理解上的歧义。
清浅池塘
程序员，专栏：Java那些事儿唯一作者，咨询前请先点详细资料
修改记录：
2017年8月17日 12：00 调整了本文顺序，新增小结。
本来想先在专栏里简单的说一下二叉树，红黑树的内容后再说HashMap的，但看到评论区里不断的出现HashMap这个词，怕大家等得着急，本篇文章就先说说HashMap吧，前面讲ArrayList和LinkedList时把源码说得很细，只要理解了这两块内容，本篇内容也很好理解，先来看看HashMap在Map这个大家族中的位置。
上图中，白色部分是接口，黄色部分是要重点了解的，最好是看一遍源码，绿色部分已经过时，不常用了，但是面试中可能会问到。这里先简单的说一下这几个Map，TreeMap是基于树的实现，HashMap，HashTable，ConcurrentHashMap是基于hash表的实现，下文我们会介绍hash表。HashTable和HashMap在代码实现上，基本上是一样的，和Vector与Arraylist的区别大体上差不多，一个是线程安全的，一个非线程安全，忘记了的朋友可以去看这篇文章，传送门：Arraylist与Vector的区别。ConcurrentHashMap也是线程安全的，但性能比HashTable好很多，HashTable是锁整个Map对象，而ConcurrentHashMap是锁Map的部分结构，LinkedHashMap后续会单独开文讲解。
Map其实很简单，就是一个key，对应一个value。本章我们重点了解HashMap，话不多说，上代码：
执行构造函数，当我们看到这个new，第一反应应该是这货又在堆内存里开辟了一块空间。
构造函数如下：
似乎简单，就是初始化了一个负载因子
负载因子默认为0.75f，这个负载因子后续会详说。
嘿嘿，又看到了传说中的数组，数组里原对象是Node，来看一下Node是什么鬼
其实很简单，一些属性，一个key，一个value，用来保存我们往Map里放入的数据，next用来标记Node节点的下一个元素。目前还没有任何代码用到Node，我们只能从成员变量入手了
这两个就不多说了吧，一个是逻辑长度，一个是修改次数，ArrayList，LinkedList也有这两个属性，老规矩，我们来画一画
HashMap我们就初始化好了，成员变量table数组默认为null，size默认为0，负载因子为0.75f，初始化完成，往里添加元素，来看一下put的源码
就一行代码，调用了putVal方法，其中key是传进来的“张三”这个字符串对象，value是“张三”这个Person对象，调用了一个方法hash()，再看一下
看到了熟悉的hashCode，我们在前面的文章里已经强调过很多次了，重写equals方法的时候，一定要重写hashCode方法，因为key是基于hashCode来处理的。继续看putVal方法
resize方法比较复杂，这儿就不完全贴出来了，当放入第一个元素时，会触发resize方法的以下关键代码
再看这个DEFAULT_INITIAL_CAPACITY是什么东东
又是传说中的移位运算符，1 << 4 其实就是相当于16。
恩，这句是关键，当我们放入第一个元素时，如果底层数组还是null，系统会初始化一个长度为16的Node数组，像极了ArrayList的初始化。
最后返回new出来的数组，继续画图，由于篇幅有限，下图中省略了部分数组内容，注意，虽然数组长度为16，但逻辑长度size依然是0
继续执行下图中putVal方法里的红框内容
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);
}这个hash值是字符串“张三”这个对象的hashCode方法与hashMap提供hash()方法共同计算出来的结果，其中n是数组的长度，目前数组长度为16，不管这个hash的值是多少，经过(n - 1) & hash计算出来的i 的值一定在n-1之间。刚好是底层数组的合法下标，用i这个下标值去底层数组里去取值，如果为null，创建一个Node放到数组下标为i的位置。这里的“张三”计算出来的i的值为2，继续画图
继续添加元素“李四”，“王五”，“赵六”，一切正常，key：“李四”经过(n - 1) & hash算出来在数组下标位置为1，“王五”为7，“赵六”为9，添加完成后如下图
上图更趋近于堆内存中的样子，但看起来比较复杂，我们简化一下
上图是简化后的堆内存图。继续往里添加“孙七”，通过(n - 1) & hash计算“孙七”这个key时计算出来的下标值是1，而数组下标1这个位置目前已经被“李四”给占了，产生了冲突。相信大家在看本文的过程中也有这样的疑惑，万一计算出来的下标值i重了怎么办？我们来看一看HashMap是怎么解决冲突的。
上图中红框里就是冲突的处理，这一句是关键
p.next = newNode(hash, key, value, null);也就是说new一个新的Node对象并把当前Node的next引用指向该对象，也就是说原来该位置上只有一个元素对象，现在转成了单向链表，继续画图
继续添加其它元素，添加完成后如下
到这里，我们的元素就添加完了。我们debug看一下
大框里的内容是链表的体现，小框里的内容是单元素的体现。
红框中还有两行比较重要的代码
if (binCount >= TREEIFY_THRESHOLD - 1) //当binCount>=TREEIFY_THRESHOLD-1
treeifyBin(tab, hash);//把链表转化为红黑树再看看TREEIFY_THRESHOLD的值
当链表长度到8时，将链表转化为红黑树来处理，由于树相关的内容本专栏还未讲解，红黑树的内容这里就不深入了。树在内存中的样子我们还是画个图简单的了解一下
在JDK1.7及以前的版本中，HashMap里是没有红黑树的实现的，在JDK1.8中加入了红黑树是为了防止哈希表碰撞攻击，当链表链长度为8时，及时转成红黑树，提高map的效率。在面试过程中，能说出这一点，面试官会对你加分不少。
注：本章所讲的移位运算符（如：“<<”）、位运算符（如：“&”），红黑树、哈希表碰撞攻击等，这里不做详解，大家有兴趣的话请在评论区留言，响应的人多的话，会单独开文讲解。
思考下面代码：
hash方法的实现：
在put放入元素时，HashMap又自己写了一个hash方法来计算hash值，大家想想看，为什么不用key本身的hashCode方法，而是又处理了一下？
本文到这里先告一个段落，先做一个小结。
HashMap的最底层是数组来实现的，数组里的元素可能为null，也有可能是单个对象，还有可能是单向链表或是红黑树。
文中的resize在底层数组为null的时候会初始化一个数组，不为null的情况下会去扩容底层数组，并会重排底层数组里的元素。
如果喜欢本系列文章，请为我点赞或顺手分享，您的支持是我继续下去的动力，您也可以在评论区留言想了解的内容，有机会本专栏会做讲解，最后别忘了关注一下我。
HashMap底层实现原理（下）
清浅池塘
程序员，专栏：Java那些事儿唯一作者，咨询前请先点详细资料
197 人赞同了该文章
公众号：saysayJava，敬请支持。
上一篇文章我们介绍了HashMap的底层实现，但还遗留了一点内容，我们再回顾一下上一篇文章里说的内容
执行完红框里的代码，personMap里放入了8个元素，放置完成后在堆内存表现如下图
如果忽略底层实现细节，是这样的
在Map中，一个key，对应了一个value，如果key的值已经存在，Map会直接替换value的内容，来看一下源码中是怎么实现的，来看以下代码
Person oldPerson1 = personMap.put("张三", new Person("新张三", 21));
Person oldPerson2 = personMap.put("孙七", new Person("新孙七", 32));
System.out.println("oldPerson1.getName() ：" + oldPerson1.getName());
System.out.println("oldPerson2.getName() : " + oldPerson2.getName());
System.out.println("personMap.size() : " + personMap.size());
new了一个Person“新张三”，注意，key依然是张三，看一下源码
放入“新张三”时，会执行以上代码1、2、5
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){//这儿P不为null，所以下面这行代码不会执行。
tab[i] = newNode(hash, key, value, null);//这行代码不会执行
}
很简单，直接在底层数组里取值赋值给p，由于p不为null，执行else里的逻辑
Node<K,V> e; K k;
if (p.hash == hash && //如果hash值相等，key也相等，或者equals相等，赋值给e
((k = p.key) == key || (key != null && key.equals(k))))
e = p;//赋值给e
又看到了熟悉的equals方法，这里我们hash值相等，key的值也相等，条件成立，把值赋值给e。（如果key的值不相等，就比较equals方法，也就是说，就算key是一个新new出来的对象，只要满足equals，也视为key相同）
if (e != null) { // existing mapping for key
V oldValue = e.value;//定义一个变量来存旧值
if (!onlyIfAbsent || oldValue == null)
e.value = value;//把value的值赋值为新的值
afterNodeAccess(e);
return oldValue;//返回的值
}
这段代码就比较简单了，用新的value替换旧value并返回旧的value。画一下图
再new一个Person“新孙七”并put到personMap中，注意，key依然是“孙七”，会执行图17-2里的1、2、3、4、5，由于2、3不满足条件，实际执行的是1、4、5，1这一步已经说过了，重点说一下4这一步
for (int binCount = 0; ; ++binCount) {//循环
if ((e = p.next) == null) {//如果循环到最后也没找到，把元素放到最后
p.next = newNode(hash, key, value, null);//把元素放到最后
if (binCount >= TREEIFY_THRESHOLD - 1) //如果长度超>=8，转换成红黑树
treeifyBin(tab, hash);//转换成红黑树
break;
}
if (e.hash == hash && //这段代码和第2步一样
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;//如果hash值相等，key也相等或者equals相等，赋值给e
}
}
}
其实就是循环链表的节点，直到找到"孙七"这个key，然后执行图17-2里的第5步，如果找不到，就添加到最后，这里我们key是“孙七”，在链表中找到元素替换value即可，再画一下图
最后来看看放到树里的方法putTreeVal，由于树的内容我们还没涉及到，下面只标注出了关键代码
和链表类似，循环（遍历）树的节点，如果找到节点，返回节点，执行图17-2里的第5步更新value。如果循环完整颗数都找不到相应的key，添加新节点。
最后我们看一下本文初那段示例代码的执行结果：
虽然元素已经替换成新的值，但示例中打印的是替换前的值，元素个数还是8不变，debug看一下，是不是value更新成功了
更新已经成功。
结合上一篇内容，做一个总结，在hashMap中放入（put）元素，有以下重要步骤：
1、计算key的hash值，算出元素在底层数组中的下标位置。
2、通过下标位置定位到底层数组里的元素（也有可能是链表也有可能是树）。
3、取到元素，判断放入元素的key是否==或equals当前位置的key，成立则替换value值，返回旧值。
4、如果是树，循环树中的节点，判断放入元素的key是否==或equals节点的key，成立则替换树里的value，并返回旧值，不成立就添加到树里。
5、否则就顺着元素的链表结构循环节点，判断放入元素的key是否==或equals节点的key，成立则替换链表里value，并返回旧值，找不到就添加到链表的最后。
精简一下，判断放入HashMap中的元素要不要替换当前节点的元素，key满足以下两个条件即可替换：
1、hash值相等。
2、==或equals的结果为true。
由于hash算法依赖于对象本身的hashCode方法，所以对于HashMap里的元素来说，hashCode方法与equals方法非常的重要，这也是在说说Java里的equals（中）一文中强调重写对象的equals方法一定要重写hashCode方法的原因，不重写的话，放到HashMap中可能会得不到你想要的结果！本示例中放入的key是String类型的，String这个类已经重写了hashCode方法，有兴趣的朋友可以自行查看源码。
如果喜欢本系列文章，请为我点赞或顺手分享，您的支持是我继续下去的动力，您也可以在评论区留言想了解的内容，有机会本专栏会做讲解，最后别忘了关注一下我。
HashSet的秘密
清浅池塘
程序员，专栏：Java那些事儿唯一作者，咨询前请先点详细资料
153 人赞同了该文章
HashMap还没讲完，还有几篇文章，目前在构思中，HashMap是集合类的精华，底层实现也比较复杂，真正理解了HashMap，也算是上了小小的一层台阶。
这篇文章我们先轻松一下，不讲HashMap，来说说HashSet。如果有点Java基础的童鞋，应该都知道List和Set都实现自Collection，List保证元素的添加顺序，元素可重复。而Set不保证元素的添加顺序，元素不可重复
先来看看Set家族在Collection中的位置，红框里的内容就是Set的大家族了，Set接口继承自Collection。有两个很重要的实现HashSet和TreeSet。其中黄色部分前面已经说过了是要重点了解的，老规矩，上代码，大家可以先想一想以下代码的执行结果。
public static void main(String[] args){
Set<String> strSet = new HashSet<>();//new了一个HashSet
strSet.add("张三");
strSet.add("李四");
strSet.add("王五");
strSet.add("赵六");
System.out.println("strSet : " + strSet);
System.out.println("strSet.size() : " + strSet.size());
System.out.println("strSet里是否为空 : " + strSet.isEmpty());
System.out.println("删除王五。。。。");
boolean delFlag = strSet.remove("王五");
System.out.println("删除王五是否成功" + delFlag);
System.out.println("删除王五后的strSet : " + strSet);
System.out.println("strSet中是否包含王五：" + strSet.contains("王五"));
System.out.println("strSet中是否包含张三：" + strSet.contains("张三"));
System.out.println("clear清除元素...");
strSet.clear();
System.out.println("clear清除元素后的strSet : " + strSet);
System.out.println("strSet长度 : " + strSet.size());
System.out.println("strSet里是否为空 : " + strSet.isEmpty());
}
先来看第一行代码：
Set<String> strSet = new HashSet<>();//new了一个HashSet
new了一个HashSet，前面的文章已经说过很多次了，只要是看到new，这货肯定在堆内存里开辟了一块空间，先找到HashSet的构造函数看看，看到如下代码：
等等，怎么出现了HashMap，这个HashMap到底是什么鬼？再看一下map，追踪一下
就是一个HashMap，老规矩画图吧
HashMap的初始化在HashMap底层实现原理（上）一文中已经说过了，这里就不再详解了，需要了解的朋友请自行回顾。继续执行以下代码，往strSet添加元素"张三"
strSet.add("张三");
再看add方法
上面红框里的这行代码和等同于
boolean putFlag = map.put(e,PRESENT);
return putFlag;
原来就是调用底层HashMap的put方法，把"张三"作为key，PRESENT作为value放在hashMap里，讲HashMap的时候讲过了，如果put时key重了，会返回被覆盖的value值（oldValue），否则返回null，这儿的HashSet又给包装了一下，如果key没有重（oldValue == null），就返回true，否则返回false。继续看这个PRESENT是什么鬼
很简单就是new了一个Object，继续画图
调用底层HashMap的时候，key是传进去的“张三”，value是PRESENT，也就是一个Object对象，继续往里添加“李四”，“王五”，“赵六”
strSet.add("李四");
strSet.add("王五");
strSet.add("赵六");
依次放入“李四”，“王五”，“赵六”，value都是一样的，为PRESENT，继续画图
所有元素的value都指向Object对象，HashSet虽然底层是用HashMap来实现的，但由于用不到HashMap的value，所以不会为底层HashMap的每个value分配一个内存空间，因此并不会过多的占用内存，请放心使用。
再来看看示例代码里的size()、isEmpty()、remove()、contains()、clear()等方法的实现
调用的是底层HashMap的size方法
调用的是底层HashMap的isEmpty方法
调用的是底层HashMap的remove方法
调用的是底层HashMap的contains方法
调用的是HashMap的clear方法。
这些方法基本上没什么逻辑代码，就是复用了HashMap里的方法而已。HashSet就是利用HashMap来实现的。这时候我们大胆的猜测一下，TreeSet是不是也是用TreeMap来实现的呢？迫不及待打开TreeSet的源码
构造函数this调了另一个构造函数
再来看m
这个m是NavigableMap类型的，NavigableMap只是一个接口而已
再来看TreeMap，实现了NavigableMap这个接口
绕了好大一个圈，其实就是相当于
NavigableMap m = new TreeMap<>();
也就是说，TreeSet底层实现也是利用TreeMap来实现的，再来看看TreeSet的其它方法
调用的是底层TreeMap的size方法
调用的是底层TreeMap的isEmpty方法
TreeMap的add方法是调用底层TreeMap的put方法，只是改了个名字而已
其它方法大致上也是如此，就不一一举例说明了，感兴趣的朋友请自行阅读源码。
最后，执行一下本文开始那段示例代码的执行结果
注：本文示例代码，已上传至公众号：saysayJava，需要练习的朋友请自行下载。
小结：HashSet底层声明了一个HashMap，HashSet做了一层包装，操作HashSet里的元素时其实是在操作HashMap里的元素。TreeSet底层也是声明了一个TreeMap，操作TreeSet里的元素其实是操作TreeMap里的元素。
本文刚一上线就收到了大量评论，评论区里有人说TreeSet和LinkedHashSet是有序的，这里强调一下，我们指的Set不保证插入有序是指Set这个接口的规范，实现类只要遵循这个规范即可，当然也可以写有序的版本出来，比如LinkedHashSet。而TreeSet是里面的内容有序（按照一定规则排序），但不是指元素的添加顺序。
注意：大家在写TreeSet测试本文代码的时候，可能刚好得到张三，李四，王五、赵六这样的顺序，这是碰巧，请大家打乱顺序测试。
最后：感谢
@程序猎人
一直以来对本专栏的勘误工作。感谢
@阿法利亚
经过他在评论区提出的质疑，本文修正并补充了一些地方，减少读者一些理解上的歧义。
清浅池塘
程序员，专栏：Java那些事儿唯一作者，咨询前请先点详细资料
公众号：saysayJava，敬请支持。
上一篇文章我们介绍了HashMap的底层实现，但还遗留了一点内容，我们再回顾一下上一篇文章里说的内容
执行完红框里的代码，personMap里放入了8个元素，放置完成后在堆内存表现如下图
如果忽略底层实现细节，是这样的
在Map中，一个key，对应了一个value，如果key的值已经存在，Map会直接替换value的内容，来看一下源码中是怎么实现的，来看以下代码
Person oldPerson1 = personMap.put("张三", new Person("新张三", 21));
Person oldPerson2 = personMap.put("孙七", new Person("新孙七", 32));
System.out.println("oldPerson1.getName() ：" + oldPerson1.getName());
System.out.println("oldPerson2.getName() : " + oldPerson2.getName());
System.out.println("personMap.size() : " + personMap.size());new了一个Person“新张三”，注意，key依然是张三，看一下源码
放入“新张三”时，会执行以上代码1、2、5
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){//这儿P不为null，所以下面这行代码不会执行。
tab[i] = newNode(hash, key, value, null);//这行代码不会执行
}很简单，直接在底层数组里取值赋值给p，由于p不为null，执行else里的逻辑
Node<K,V> e; K k;
if (p.hash == hash && //如果hash值相等，key也相等，或者equals相等，赋值给e
((k = p.key) == key || (key != null && key.equals(k))))
e = p;//赋值给e又看到了熟悉的equals方法，这里我们hash值相等，key的值也相等，条件成立，把值赋值给e。（如果key的值不相等，就比较equals方法，也就是说，就算key是一个新new出来的对象，只要满足equals，也视为key相同）
if (e != null) { // existing mapping for key
V oldValue = e.value;//定义一个变量来存旧值
if (!onlyIfAbsent || oldValue == null)
e.value = value;//把value的值赋值为新的值
afterNodeAccess(e);
return oldValue;//返回的值
}这段代码就比较简单了，用新的value替换旧value并返回旧的value。画一下图
再new一个Person“新孙七”并put到personMap中，注意，key依然是“孙七”，会执行图17-2里的1、2、3、4、5，由于2、3不满足条件，实际执行的是1、4、5，1这一步已经说过了，重点说一下4这一步
for (int binCount = 0; ; ++binCount) {//循环
if ((e = p.next) == null) {//如果循环到最后也没找到，把元素放到最后
p.next = newNode(hash, key, value, null);//把元素放到最后
if (binCount >= TREEIFY_THRESHOLD - 1) //如果长度超>=8，转换成红黑树
treeifyBin(tab, hash);//转换成红黑树
break;
}
if (e.hash == hash && //这段代码和第2步一样
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;//如果hash值相等，key也相等或者equals相等，赋值给e
}
}
}其实就是循环链表的节点，直到找到"孙七"这个key，然后执行图17-2里的第5步，如果找不到，就添加到最后，这里我们key是“孙七”，在链表中找到元素替换value即可，再画一下图
最后来看看放到树里的方法putTreeVal，由于树的内容我们还没涉及到，下面只标注出了关键代码
和链表类似，循环（遍历）树的节点，如果找到节点，返回节点，执行图17-2里的第5步更新value。如果循环完整颗数都找不到相应的key，添加新节点。
最后我们看一下本文初那段示例代码的执行结果：
虽然元素已经替换成新的值，但示例中打印的是替换前的值，元素个数还是8不变，debug看一下，是不是value更新成功了
更新已经成功。
结合上一篇内容，做一个总结，在hashMap中放入（put）元素，有以下重要步骤：
1、计算key的hash值，算出元素在底层数组中的下标位置。
2、通过下标位置定位到底层数组里的元素（也有可能是链表也有可能是树）。
3、取到元素，判断放入元素的key是否==或equals当前位置的key，成立则替换value值，返回旧值。
4、如果是树，循环树中的节点，判断放入元素的key是否==或equals节点的key，成立则替换树里的value，并返回旧值，不成立就添加到树里。
5、否则就顺着元素的链表结构循环节点，判断放入元素的key是否==或equals节点的key，成立则替换链表里value，并返回旧值，找不到就添加到链表的最后。
精简一下，判断放入HashMap中的元素要不要替换当前节点的元素，key满足以下两个条件即可替换：
1、hash值相等。
2、==或equals的结果为true。
由于hash算法依赖于对象本身的hashCode方法，所以对于HashMap里的元素来说，hashCode方法与equals方法非常的重要，这也是在说说Java里的equals（中）一文中强调重写对象的equals方法一定要重写hashCode方法的原因，不重写的话，放到HashMap中可能会得不到你想要的结果！本示例中放入的key是String类型的，String这个类已经重写了hashCode方法，有兴趣的朋友可以自行查看源码。
如果喜欢本系列文章，请为我点赞或顺手分享，您的支持是我继续下去的动力，您也可以在评论区留言想了解的内容，有机会本专栏会做讲解，最后别忘了关注一下我。
HashSet的秘密
清浅池塘
程序员，专栏：Java那些事儿唯一作者，咨询前请先点详细资料
153 人赞同了该文章
HashMap还没讲完，还有几篇文章，目前在构思中，HashMap是集合类的精华，底层实现也比较复杂，真正理解了HashMap，也算是上了小小的一层台阶。
这篇文章我们先轻松一下，不讲HashMap，来说说HashSet。如果有点Java基础的童鞋，应该都知道List和Set都实现自Collection，List保证元素的添加顺序，元素可重复。而Set不保证元素的添加顺序，元素不可重复
先来看看Set家族在Collection中的位置，红框里的内容就是Set的大家族了，Set接口继承自Collection。有两个很重要的实现HashSet和TreeSet。其中黄色部分前面已经说过了是要重点了解的，老规矩，上代码，大家可以先想一想以下代码的执行结果。
public static void main(String[] args){
Set<String> strSet = new HashSet<>();//new了一个HashSet
strSet.add("张三");
strSet.add("李四");
strSet.add("王五");
strSet.add("赵六");
System.out.println("strSet : " + strSet);
System.out.println("strSet.size() : " + strSet.size());
System.out.println("strSet里是否为空 : " + strSet.isEmpty());
System.out.println("删除王五。。。。");
boolean delFlag = strSet.remove("王五");
System.out.println("删除王五是否成功" + delFlag);
System.out.println("删除王五后的strSet : " + strSet);
System.out.println("strSet中是否包含王五：" + strSet.contains("王五"));
System.out.println("strSet中是否包含张三：" + strSet.contains("张三"));
System.out.println("clear清除元素...");
strSet.clear();
System.out.println("clear清除元素后的strSet : " + strSet);
System.out.println("strSet长度 : " + strSet.size());
System.out.println("strSet里是否为空 : " + strSet.isEmpty());
}
先来看第一行代码：
Set<String> strSet = new HashSet<>();//new了一个HashSet
new了一个HashSet，前面的文章已经说过很多次了，只要是看到new，这货肯定在堆内存里开辟了一块空间，先找到HashSet的构造函数看看，看到如下代码：
等等，怎么出现了HashMap，这个HashMap到底是什么鬼？再看一下map，追踪一下
就是一个HashMap，老规矩画图吧
HashMap的初始化在HashMap底层实现原理（上）一文中已经说过了，这里就不再详解了，需要了解的朋友请自行回顾。继续执行以下代码，往strSet添加元素"张三"
strSet.add("张三");
再看add方法
上面红框里的这行代码和等同于
boolean putFlag = map.put(e,PRESENT);
return putFlag;
原来就是调用底层HashMap的put方法，把"张三"作为key，PRESENT作为value放在hashMap里，讲HashMap的时候讲过了，如果put时key重了，会返回被覆盖的value值（oldValue），否则返回null，这儿的HashSet又给包装了一下，如果key没有重（oldValue == null），就返回true，否则返回false。继续看这个PRESENT是什么鬼
很简单就是new了一个Object，继续画图
调用底层HashMap的时候，key是传进去的“张三”，value是PRESENT，也就是一个Object对象，继续往里添加“李四”，“王五”，“赵六”
strSet.add("李四");
strSet.add("王五");
strSet.add("赵六");
依次放入“李四”，“王五”，“赵六”，value都是一样的，为PRESENT，继续画图
所有元素的value都指向Object对象，HashSet虽然底层是用HashMap来实现的，但由于用不到HashMap的value，所以不会为底层HashMap的每个value分配一个内存空间，因此并不会过多的占用内存，请放心使用。
再来看看示例代码里的size()、isEmpty()、remove()、contains()、clear()等方法的实现
调用的是底层HashMap的size方法
调用的是底层HashMap的isEmpty方法
调用的是底层HashMap的remove方法
调用的是底层HashMap的contains方法
调用的是HashMap的clear方法。
这些方法基本上没什么逻辑代码，就是复用了HashMap里的方法而已。HashSet就是利用HashMap来实现的。这时候我们大胆的猜测一下，TreeSet是不是也是用TreeMap来实现的呢？迫不及待打开TreeSet的源码
构造函数this调了另一个构造函数
再来看m
这个m是NavigableMap类型的，NavigableMap只是一个接口而已
再来看TreeMap，实现了NavigableMap这个接口
绕了好大一个圈，其实就是相当于
NavigableMap m = new TreeMap<>();
也就是说，TreeSet底层实现也是利用TreeMap来实现的，再来看看TreeSet的其它方法
调用的是底层TreeMap的size方法
调用的是底层TreeMap的isEmpty方法
TreeMap的add方法是调用底层TreeMap的put方法，只是改了个名字而已
其它方法大致上也是如此，就不一一举例说明了，感兴趣的朋友请自行阅读源码。
最后，执行一下本文开始那段示例代码的执行结果
注：本文示例代码，已上传至公众号：saysayJava，需要练习的朋友请自行下载。
小结：HashSet底层声明了一个HashMap，HashSet做了一层包装，操作HashSet里的元素时其实是在操作HashMap里的元素。TreeSet底层也是声明了一个TreeMap，操作TreeSet里的元素其实是操作TreeMap里的元素。
本文刚一上线就收到了大量评论，评论区里有人说TreeSet和LinkedHashSet是有序的，这里强调一下，我们指的Set不保证插入有序是指Set这个接口的规范，实现类只要遵循这个规范即可，当然也可以写有序的版本出来，比如LinkedHashSet。而TreeSet是里面的内容有序（按照一定规则排序），但不是指元素的添加顺序。
注意：大家在写TreeSet测试本文代码的时候，可能刚好得到张三，李四，王五、赵六这样的顺序，这是碰巧，请大家打乱顺序测试。
最后：感谢
@程序猎人
一直以来对本专栏的勘误工作。感谢
@阿法利亚
经过他在评论区提出的质疑，本文修正并补充了一些地方，减少读者一些理解上的歧义。
清浅池塘
程序员，专栏：Java那些事儿唯一作者，咨询前请先点详细资料
HashMap还没讲完，还有几篇文章，目前在构思中，HashMap是集合类的精华，底层实现也比较复杂，真正理解了HashMap，也算是上了小小的一层台阶。
这篇文章我们先轻松一下，不讲HashMap，来说说HashSet。如果有点Java基础的童鞋，应该都知道List和Set都实现自Collection，List保证元素的添加顺序，元素可重复。而Set不保证元素的添加顺序，元素不可重复
先来看看Set家族在Collection中的位置，红框里的内容就是Set的大家族了，Set接口继承自Collection。有两个很重要的实现HashSet和TreeSet。其中黄色部分前面已经说过了是要重点了解的，老规矩，上代码，大家可以先想一想以下代码的执行结果。
public static void main(String[] args){
Set<String> strSet = new HashSet<>();//new了一个HashSet
strSet.add("张三");
strSet.add("李四");
strSet.add("王五");
strSet.add("赵六");
System.out.println("strSet : " + strSet);
System.out.println("strSet.size() : " + strSet.size());
System.out.println("strSet里是否为空 : " + strSet.isEmpty());
System.out.println("删除王五。。。。");
boolean delFlag = strSet.remove("王五");
System.out.println("删除王五是否成功" + delFlag);
System.out.println("删除王五后的strSet : " + strSet);
System.out.println("strSet中是否包含王五：" + strSet.contains("王五"));
System.out.println("strSet中是否包含张三：" + strSet.contains("张三"));
System.out.println("clear清除元素...");
strSet.clear();
System.out.println("clear清除元素后的strSet : " + strSet);
System.out.println("strSet长度 : " + strSet.size());
System.out.println("strSet里是否为空 : " + strSet.isEmpty());
}先来看第一行代码：
Set<String> strSet = new HashSet<>();//new了一个HashSetnew了一个HashSet，前面的文章已经说过很多次了，只要是看到new，这货肯定在堆内存里开辟了一块空间，先找到HashSet的构造函数看看，看到如下代码：
等等，怎么出现了HashMap，这个HashMap到底是什么鬼？再看一下map，追踪一下
就是一个HashMap，老规矩画图吧
HashMap的初始化在HashMap底层实现原理（上）一文中已经说过了，这里就不再详解了，需要了解的朋友请自行回顾。继续执行以下代码，往strSet添加元素"张三"
strSet.add("张三"); 再看add方法
上面红框里的这行代码和等同于
boolean putFlag = map.put(e,PRESENT);
return putFlag;原来就是调用底层HashMap的put方法，把"张三"作为key，PRESENT作为value放在hashMap里，讲HashMap的时候讲过了，如果put时key重了，会返回被覆盖的value值（oldValue），否则返回null，这儿的HashSet又给包装了一下，如果key没有重（oldValue == null），就返回true，否则返回false。继续看这个PRESENT是什么鬼
很简单就是new了一个Object，继续画图
调用底层HashMap的时候，key是传进去的“张三”，value是PRESENT，也就是一个Object对象，继续往里添加“李四”，“王五”，“赵六”
strSet.add("李四");
strSet.add("王五");
strSet.add("赵六"); 依次放入“李四”，“王五”，“赵六”，value都是一样的，为PRESENT，继续画图
所有元素的value都指向Object对象，HashSet虽然底层是用HashMap来实现的，但由于用不到HashMap的value，所以不会为底层HashMap的每个value分配一个内存空间，因此并不会过多的占用内存，请放心使用。
再来看看示例代码里的size()、isEmpty()、remove()、contains()、clear()等方法的实现
调用的是底层HashMap的size方法
调用的是底层HashMap的isEmpty方法
调用的是底层HashMap的remove方法
调用的是底层HashMap的contains方法
调用的是HashMap的clear方法。
这些方法基本上没什么逻辑代码，就是复用了HashMap里的方法而已。HashSet就是利用HashMap来实现的。这时候我们大胆的猜测一下，TreeSet是不是也是用TreeMap来实现的呢？迫不及待打开TreeSet的源码
构造函数this调了另一个构造函数
再来看m
这个m是NavigableMap类型的，NavigableMap只是一个接口而已
再来看TreeMap，实现了NavigableMap这个接口
绕了好大一个圈，其实就是相当于
NavigableMap m = new TreeMap<>();也就是说，TreeSet底层实现也是利用TreeMap来实现的，再来看看TreeSet的其它方法
调用的是底层TreeMap的size方法
调用的是底层TreeMap的isEmpty方法
TreeMap的add方法是调用底层TreeMap的put方法，只是改了个名字而已
其它方法大致上也是如此，就不一一举例说明了，感兴趣的朋友请自行阅读源码。
最后，执行一下本文开始那段示例代码的执行结果
注：本文示例代码，已上传至公众号：saysayJava，需要练习的朋友请自行下载。
小结：HashSet底层声明了一个HashMap，HashSet做了一层包装，操作HashSet里的元素时其实是在操作HashMap里的元素。TreeSet底层也是声明了一个TreeMap，操作TreeSet里的元素其实是操作TreeMap里的元素。
本文刚一上线就收到了大量评论，评论区里有人说TreeSet和LinkedHashSet是有序的，这里强调一下，我们指的Set不保证插入有序是指Set这个接口的规范，实现类只要遵循这个规范即可，当然也可以写有序的版本出来，比如LinkedHashSet。而TreeSet是里面的内容有序（按照一定规则排序），但不是指元素的添加顺序。
注意：大家在写TreeSet测试本文代码的时候，可能刚好得到张三，李四，王五、赵六这样的顺序，这是碰巧，请大家打乱顺序测试。
最后：感谢
@程序猎人
一直以来对本专栏的勘误工作。感谢
@阿法利亚
经过他在评论区提出的质疑，本文修正并补充了一些地方，减少读者一些理解上的歧义。
