JDK源码学习——集合，2024年最新面试说让后天过去上班

2401_84103488

于 2024-04-20 04:29:45 发布

阅读量771

点赞数 19

分类专栏： 2024年程序员学习文章标签： java 学习面试

本文链接：https://blog.csdn.net/2401_84103488/article/details/137985390

版权

2024年程序员学习专栏收录该内容

191 篇文章 2 订阅

订阅专栏

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注Java）

正文

arrayList 与linkedList区别：arrayList是基于数组实现的，所以查询的速度很快，但是删除和添加一个元素就相对慢。linkedList 是基于链表实现的，所以查询速度比arrayList慢，但是添加和删除元素的速度快。

1 ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。

2 对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。

3 对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。

接着来学习，在集合中所有的元素都实现了Iterator接口，用于遍历元素。

boolean hasNext()：这个方法是在遍历的时候，判断是否还有更多的元素

E next()：返回下一个元素

default void remove()：这里涉及到了jdk8的特性，在接口定义中，将方法描述为default-虚拟扩展方法，就可以在接口中进行默认实现，从而提高接口的扩展性，避免在接口扩展的时候，破坏原有的实现。

default void forEachRemaining(Consumer<? super E> action)：这个方面一般都用不到，不做具体描述。

collection

Collection作为一个集合类的顶层接口，他没有直接的子类实现，而是通过实现它的子接口来实现集合容器。Collection的特点是作为一个容器，他可以轻松的帮用户实现数据存储，动态扩容，还有方便的元素遍历和快速的增删改查等操作，这些特点都在接口定义的方法中一一体现出来，相比我们用array来存储数据方便不少。

Collection的子接口主要是三大类分别是List，Set和Queue。这三个接口各有特点。

list是顺序存储的，并且可以重复，可以为空

Set 集合最大的特点是元素不能重复，所有元素都是唯一的存在。Set集合不保证维护元素的顺序

Queue 顾名思义就是队列，队列最大的特点就是FIFO先进先出，与之对应的有栈Stack后进先出。

Map

和Collection一样，Map也是集合容器的一个顶层接口。Map是通过key-value方式存储数据，key值都是唯一的，但key是否能为空，则要看他的不同子类的实现。我们可以把Map看成一个小型的数字字典，通过key值的方式存储数据性能非常快，比如他的子类Hashmap，底层就是通过散列表来实现存储，他的时间复杂度是O(1)。另一个典型的子类Treemap是基于红黑树实现的，时间复杂度为O(log n)。以下将介绍部分方法。

HashSet

先说说HashSet的继承关系，HashSet继承了AbstractSet抽象类并实现了Set接口，AbstractSet的子类还包括TreeSet，里面实现了两个类公共的一部分方法，后面也会略有介绍。

那么HashSet到底一个怎么样的存在呢?HashSet顾名思义就是通过Hash表的方式存储数据，既然提到hash，那么肯定少不了HashMap，其实HashSet很聪明，他只需在内部维护了一个HashMap实例，将数据存储在了map中，并且集合元素不能重复。因此HashSet可以说是集合类中实现最简单的一个，他基本就是实现了List接口中定义的几个方法。

那么我想说HashSet和HashMap有什么区别呢？

1.HashMap提供键值对的方式存储数据，而HashSet仅仅提供数据存储，并没有键值对应。他获取元素的方式也只能通过遍历的方式逐个获取

2.HashMap在存入数据的时候是更加key值的hash值判断，而HashSet需要重写hashCode和equals两个方法，如果不重写则会调用默认的实现，用户在使用HashSet的时候要特别注意元素的euqals判断，有必要的话要重写一个，以免出现问题。

HashMap

HashMap是Map的一个实现类，这个类很重要，是很多集合类的实现基础，底层用的就是他，比如前文中讲到的HashSet，下文要讲到的LinkedHashMap。我们可以将HashMap看成是一个小型的数字字典，他以key-value的方式保存数据，Key全局唯一，并且key和value都允许为null。

HashMap底层是通过维护一个数据来保存元素。当创建HashMap实例的时候，会通过指定的数组大小以及负载因子等参数创建一个空的数组，当在容器中添加元素的时候，首先会通过hash算法求得key的hash值，再根据hash值确定元素在数组中对应的位置，最后将元素放入数组对应的位置。在添加元素的过程中会出现hash冲突问题，冲突处理的方法就是判断key值是否相同，如果相同则表明是同一个元素，替换value值。如果key值不同，则把当前元素添加到链表尾部。这里引出了一个概念，就是HashMap的数据结构其实是：hash表+单向链表。通过链表的方式把所有冲突元素放在了数组的同一个位置。但是当链表过长的时候会影响HashMap的存取效率。因此我们在实际使用HashMap的时候就需要考虑到这个问题，那么该如何控制hash冲突的出现频率呢？HashMap中有一个负载因子(loadFactor)的概念。容器中实际存储元素的size = loadFactor * 数组长度，一旦容器元素超出了这个size，HashMap就会自动扩容，并对所有元素重新执行hash操作，调整位置。好了说了这么多，下面就开始介绍源码实现。

hashMap 的数组大小必须是2 的幂，至于为什么，感兴趣的可以搜一下，这里先不说了，我想要的讲的是HashMap 的put方法，也就是为马map中添加一个元素。Map添加元素的方式是通过put，向容器中存入一个Key-Value对。下面我将详细介绍put的实现过程，这个方法非常重要，吃透了这个方法的实现原理，基本也就能搞懂HashMap是怎么一回事了。

大致上：首先会判断是否第一次添加元素，如果是第一次，就会先创建一个一定大小的数组（table）。接着通过hash与数组长度的操作，确定key对应的位置，也就是key值通过hash算法在数组中确定存储位置。如果找到的位置为空，那么就在当前数组位置，为这个key-value创建一个节点。如果对应的位置有值，则会和key值进行比较，如果key值相同，则表明是同一个元素，直接把value值替换。如果key值不相同，那么就会进行遍历整个数组，如果找到了有相同的key值，则在对应位置替换其value值。如果没有找到相同的key值，那么就在链表尾部添加中这个元素。源代码如下：

public V put(K key, V value) {

return putVal(hash(key), key, value, false, true);

}

// 获取key的hash值，这里讲hash值的高16位右移和低16位做异或操作，目的是为了减少hash冲突，使hash值能均匀分布。

static final int hash(Object key) {

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;

// 如果是第一次添加元素，那么table是空的，首先创建一个指定大小的table。

if ((tab = table) == null || (n = tab.length) == 0)

n = (tab = resize()).length;

// 通过对hash与数组长度的与操作，确定key对应的数组位置，然后读取该位置中的元素。

if ((p = tab[i = (n - 1) & hash]) == null)

// 如果当前位置为空，那么就在当前数组位置，为这个key-value创建一个节点。

tab[i] = newNode(hash, key, value, null);

else {

// 如果当前位置已经存在元素，那么就要逐个读取这条链表的元素。

Node<K,V> e; K k;

// 如果key和hash值都等于当前头元素，那么这存放的两个元素是相同的。

if (p.hash == hash &&

((k = p.key) == key || (key != null && key.equals(k))))

e = p;

// 如果当前位置的链表类型是TreeNode，那么就讲当前元素以红黑树的形式存放。

else if (p instanceof TreeNode)

e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);

else {

for (int binCount = 0; ; ++binCount) {

// 遍历链表的所有元素，如果都未找到相同key的元素，那么说明这个元素并不在容器中存在，因此将他添加到链表尾部，并结束遍历。

if ((e = p.next) == null) {

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

if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st

treeifyBin(tab, hash);

break;

}

// 如果在遍历过程中，发现了相同的key值，那么就结束遍历。

if (e.hash == hash &&

((k = e.key) == key || (key != null && key.equals(k))))

break;

p = e;

}

// 如果e != null 说明在当前容器中，存在一个相同的key值，那么就要替换key所对应的value

if (e != null) {

V oldValue = e.value;

if (!onlyIfAbsent || oldValue == null)

e.value = value;

// 这是专门留给LinkedHashMap调用的回调函数，LinkedHashMap会实现这个方法。从这里可以看出，HashMap充分的考虑了他的扩展性。

afterNodeAccess(e);

return oldValue;

}

++modCount;

// 这里判断当前元素的数量是否超过了容量的上限，如果超过了，就要重新进行扩容，并对当前元素重新hash，所以再次扩容以后的元素位置都是会改变的。

if (++size > threshold)

resize();

// 此方法也是HashMap留给LinkedHashMap实现的回调方法。透露一下，因为LinkedHashMap在插入元素以后，都会维护他的一个双向链表

afterNodeInsertion(evict);

return null;

}

再说一句,在put元素的过程中，可能会出现当前元素的数量超过了容量上限，那么就会进行扩容，前面提到了haspmap的容量必须为2的幂，所以每次扩容都是之前的两倍，再次扩容之后会对元素重新hash,所以元素的位置会发生改变。下面附上扩容方法的源代码：

final Node<K,V>[] resize() {

Node<K,V>[] oldTab = table;

int oldCap = (oldTab == null) ? 0 : oldTab.length;

int oldThr = threshold;

int newCap, newThr = 0;

// 如果容器并不是第一次扩容的话，那么oldCap必定会大于0

if (oldCap > 0) {

if (oldCap >= MAXIMUM_CAPACITY) {

threshold = Integer.MAX_VALUE;

return oldTab;

}

// threshold和数组大小cap共同扩大为原来的两倍

else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&

oldCap >= DEFAULT_INITIAL_CAPACITY)

newThr = oldThr << 1;

}

// 第一次扩容，并且设定了threshold值。

else if (oldThr > 0)

newCap = oldThr;

else {

// 如果在创建的时候并没有设置threshold值，那就用默认值

newCap = DEFAULT_INITIAL_CAPACITY;

newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);

}

if (newThr == 0) {

// 第一次扩容的时候threshold = cap * loadFactor

float ft = (float)newCap * loadFactor;

newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?

(int)ft : Integer.MAX_VALUE);

}

threshold = newThr;

// 创建数组

@SuppressWarnings({“rawtypes”,“unchecked”})

Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];

table = newTab;

// 如果不是第一次扩容，那么hash表中必然存在数据，需要将这些数据重新hash

if (oldTab != null) {

// 遍历所有元素

for (int j = 0; j < oldCap; ++j) {

Node<K,V> e;

if ((e = oldTab[j]) != null) {

oldTab[j] = null;

if (e.next == null)

// 重新计算在数组中的位置。

newTab[e.hash & (newCap - 1)] = e;

else if (e instanceof TreeNode)

((TreeNode<K,V>)e).split(this, newTab, j, oldCap);

else { // preserve order

// 这里分两串，lo表示原先位置的所有，hi表示新的索引

Node<K,V> loHead = null, loTail = null;

Node<K,V> hiHead = null, hiTail = null;

Node<K,V> next;

do {

最后

权威指南-第一本Docker书

引领完成Docker的安装、部署、管理和扩展，让其经历从测试到生产的整个开发生命周期，深入了解Docker适用于什么场景。并且这本Docker的学习权威指南介绍了其组件的基础知识，然后用Docker构建容器和服务来完成各种任务：利用Docker为新项目建立测试环境，演示如何使用持续集成的工作流集成Docker，如何构建应用程序服务和平台，如何使用Docker的API，如何扩展Docker。

总共包含了：简介、安装Docker、Docker入门、使用Docker镜像和仓库、在测试中使用Docker、使用Docker构建服务、使用Fig编配Docke、使用Docker API、获得帮助和对Docker进行改进等9个章节的知识。