（1）Python所有方向的学习路线（新版）
这是我花了几天的时间去把Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。
最近我才对这些路线做了一下新的更新，知识体系更全面了。
（2）Python学习视频
包含了Python入门、爬虫、数据分析和web开发的学习视频，总共100多个，虽然没有那么全面，但是对于入门来说是没问题的，学完这些之后，你可以按照我上面的学习路线去网上找其他的知识资源进行进阶。
（3）100多个练手项目
我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了，只是里面的项目比较多，水平也是参差不齐，大家可以挑自己能做的项目去练练。
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
- 第一步曲：根据key得到hashCode值
- 第二步曲：根据hashCode值计算出hash值
- 第三步曲：根据hash值计算出哈希表数组index下标
- 第四步曲：将元素节点保存到哈希表指定数组index下标
HashMap添加元素的示例代码：
HashMap<Object, Object> map = new HashMap<>();
map.put("name","Justin");
HashMap底层put(key,value)方法源码：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
再看下，hash方法实现源码：
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
接下来将解读HashMap底层源码添加元素四部曲具体实现
第一步曲：根据key得到hashCode值
以上面示例代码说明，这里key是字符串"name"，String重写了计算字符串hashCode值的hashCode()方法，源码如下：
计算得到hashCode值为3373707
第二步曲：根据hashCode值计算出hash值
hash值计算的过程用到了^（异或）和>>>(无符号右移)两种位运算
(h = key.hashCode()) ^ (h >>> 16) 即 (3373707) ^ (3373707 >>> 16)
这里为了方便展示，二进制每四位使用空格格式化，位运算过程如下：
计算key="name"的hash值二进制结果是1100110111101010111000转成十进制为3373752
进制在线转换：https://c.runoob.com/front-end/58/
即计算key="name"的hash值为3373752，也可以debug断点往后查看hash值刚好也是这个值
第三步曲：根据hash值计算出哈希表数组index下标
公式：i = (n - 1) & hash
这里公式(n - 1) & hash 用到了&按位与运算（都为1则得1），奥妙之处在于n表示HashMap中的数组容量大小，并且刚好是16,32,64…2的次方，这种情况其实是等效于 hash % n 取模计算出的数组index下标值，并且下标不会超过容量(n-1)即能够保证不会数组下标越界
但是HashMap这里没有使用%取模，而是使用位运算，直接对内存数据进行操作，效率最高，如果使用%取模需要先将内存数据转成十进制再进行运算，多了这部分的性能开销，效率会变低
HashTable底层倒是用的%取模，hash值与十六进制0x7FFFFFFF做按位与运算目的是为了保证hash值始终是正数
有的小伙伴可能会问了，使用%取模计算，那这里为啥HashTable还在用，我想说的是其实也可以优化，只不过HashTable本身就是主打synchronized线程安全，也就不考虑优化%取模为位运算了吧
第四步曲：将元素节点保存到哈希表指定数组index下标
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);
//如果遍历指定位置的链表现有节点已经是大于等于8个了
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
//则当前节点，需要通过该方法进行添加
//如果数组容量大于64，该过程会进行链表转化为红黑树
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//HashMap对于key已经存在的处理情况是
//除非该key对应的value为null，否则一律不做任何处理
//Hashtable中则是会直接更新key对应的value
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
//集合修改次数，没操作一次+1
++modCount;
//HashMap容量大小大于临界值，则进行resize()扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
终曲：为什么HashMap底层源码用这么多位运算？
关于位运算的使用，文中在介绍第三步曲时，也提到了HashMap计算数组下标使用%取模和位运算的问题，使用于位运算的奥妙之处在直接从内存读取数据进行计算，不需要转成十进制，如果使用%取模需要先转成十进制，有性能开销，效率比较低
HashMap底层除了文中提到的^按位异或、>>>无符号右移、&按位与位运算，其实在HashMap的扩容机制resize()中，还用到了<<左移运算
oldCap << 1
这里oldCap << 1刚好是两倍，可以总结的说一个数与n进行左移运算，结果为这个数乘以2的n次方
oldCap << 1 等值 oldCap = oldCap * (2的n次方)
同理，一个数与n进行右移运算结果为这个数除以2的n次方
oldCap >> 1 等值 oldCap = oldCap / (2的n次方)
**
HashMap链表转为红黑树
红黑树结构
红黑树五大特性
- 节点有红色或黑色两种；
- 根节点是黑色；
- 叶子节点全部是黑色(如图方框是叶子节点)；
- 红色节点必须配两个黑色节点（即保证任意路不会出现两个连续红色节点）；
- 从任意节点到该节点下所有叶子节点包含的黑色节点个数相同（也简称黑高）。
HashMap链表转为红黑树过程
代码示例：
public class Test {
public static void main(String[] args) {
HashMap<Object, Object> map = new HashMap<Object, Object>();
//下标为0
map.put(null, "Justin");
map.put(16, "Justin");
//下标为8
map.put(8, "Justin"); //链表第1个节点
map.put(24, "Justin"); //链表第2个节点
map.put(40, "Justin"); //链表第3个节点
map.put(56, "Justin"); //链表第4个节点
map.put(72, "Justin"); //链表第5个节点
map.put(88, "Justin"); //链表第6个节点
map.put(104, "Justin"); //链表第7个节点
map.put(120, "Justin"); //链表第8个节点
map.put("name", "Justin"); //在添加第9个节点时，链表会被转换为红黑树
}
}
上述代码添加元素完成后，大多数人认为，底层哈希表的数据结构如下：
看起来好像没啥毛病，但实际哈希表index=8的位置链表并不会转成红黑树，原因如下：
再来看下treeifyBin(tab,hash)为什么不将链表转成红黑树？
其中tab.length < MIN_TREEIFY_CAPACITY表示只要哈希表数组大小于64容量的，不可能会发生链表树化的过程，所以示例代码中，在哈希表数组下标index=8位置，添加第9个key="name"元素时，此时哈希表大小只有16， tab.length < MIN_TREEIFY_CAPACITY即16 < 64 接进行resize()扩容并重新计算各个元素存储的位置了，并不会走后面的链表转红黑树的过程。
当添加key="name"节点时，会进行扩容，容量大小由16变为32，此时oldMap数据迁移到newMap后数据排列如何呢？
这里比较简单，没涉及到红黑树的拆分，而且链表长度都是大于1个的，直接由(hash & oldCap)重新计算位置：
public class Test {
public static void main(String[] args) {
cal(null,0);
cal(16,0);
cal(8,8);
cal(24,8);
cal(40,8);
cal(56,8);
cal(88,8);
cal(72,8);
cal(104,8);
cal(120,8);
cal("name",8);
}
static void cal(Object key,int oldIndex) {
//将oldMap容量和节点hash值进行&按位与运算
if( (16 & hash(key)) == 0){//结果为0，节点放到newMap位置与在oldMap下标index位置一样
System.out.println("原key=" + key + "，迁移到newMap数组下标位置为：" + oldIndex);
}else{//结果不为0，节点放到newMap位置刚好等于oldMap下标index位置 + oldMap数组容量大小
System.out.println("原key=" + key + "，迁移到newMap数组下标位置为：" + (oldIndex + 16));
}
}
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
}
原来所有key，迁移到newMap后数组index下标位置如下：
原key=null，迁移到newMap数组下标位置为：0
原key=16，迁移到newMap数组下标位置为：16
原key=8，迁移到newMap数组下标位置为：8
原key=24，迁移到newMap数组下标位置为：24
原key=40，迁移到newMap数组下标位置为：8
原key=56，迁移到newMap数组下标位置为：24
原key=88，迁移到newMap数组下标位置为：24
原key=72，迁移到newMap数组下标位置为：8
原key=104，迁移到newMap数组下标位置为：8
原key=120，迁移到newMap数组下标位置为：24
原key=name，迁移到newMap数组下标位置为：24
所以示例代码，添加元素后，正确的数据结构应该是这样的：
通过debug断点，也可以看到扩容后节点主要被分配到了8、16、24这个三个数组下标位置：
不过一般情况下，HashMap扩容是发生在添加元素时，最后通过++size > threshold判断容量大于临界值时，才进行resize()扩容
HashMap扩容机制
- 扩容情况1：第一次添加元素会进行扩容，默认初始化容量为16
- 扩容情况2：哈希表容量小于64时，链表长度每次大于8，都会进行resize()扩容
- 扩容情况3：HashMap容量大于临界值时
几种扩容情况的源码如下：
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)
//扩容情况1：第一次添加元素会进行扩容，默认初始化容量为16
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) // -1 for 1st
//扩容情况2：见treeifyBin方法说明
treeifyBin(tab, hash);
break;
}
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;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize(); //扩容情况3：HashMap容量大于临界值时
afterNodeInsertion(evict);
return null;
}
treeifyBin源码如下：
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
//扩容情况2：哈希表容量小于64时，链表长度每次大于8，都会进行resize()扩容
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
//链表树化的过程...
}
}
再来看HashMap的resize()扩容关键源码：
final Node<K,V>[] resize() {
...
if (oldCap > 0) {
...
//oldCap << 1即2倍扩容
else if ((newCap = oldCap << 1) < MAXIMUM\_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
如果你也是看准了Python，想自学Python，在这里为大家准备了丰厚的免费**学习**大礼包，带大家一起学习，给大家剖析Python兼职、就业行情前景的这些事儿。
### 一、Python所有方向的学习路线
Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。
### 二、学习软件
工欲善其必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。
### 三、全套PDF电子书
书籍的好处就在于权威和体系健全，刚开始学习的时候你可以只看视频或者听某个人讲课，但等你学完之后，你觉得你掌握了，这时候建议还是得去看一下书籍，看权威技术书籍也是每个程序员必经之路。
### 四、入门学习视频
我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。
### 四、实战案例
光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。
### 五、面试资料
我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。
成为一个Python程序员专家或许需要花费数年时间，但是打下坚实的基础只要几周就可以，如果你按照我提供的学习路线以及资料有意识地去实践，你就有很大可能成功！
最后祝你好运！！！
**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**
**[需要这份系统化学习资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618317507)**
**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
