> 转载 - [图解Java常用数据结构(一) - 大道方圆 - 博客园 ](https://www.cnblogs.com/xdecode/p/9321848.html)
> https://www.cnblogs.com/xdecode/p/9321848.html
基于jdk8, 可能会有些特性与jdk7之前不相同, 例如LinkedList LinkedHashMap中的双向列表不再是回环的.HashMap中的单链表是尾插, 而不是头插入等等..
# 本文目录结构如下:
![图片](/api/file/getImage?fileId=5cd525178998be32c50004bf)
## LinkedList (双链表)
> 经典的双链表结构, 适用于乱序插入,删除.指定序列操作则性能不如ArrayList,这也是其数据结构决定的.
**add(E) / addLast(E)**
![图片标题](https://spider.nosdn.127.net/20eb15fd7dcc7eab7a2799f265a60d5e.gif)
**add(index, E)**
> 这边有个小的优化, 他会先判断index是靠近队头还是队尾, 来确定从哪个方向遍历链入.
```
if (index < (size >> 1)) {
Node x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
Node x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
```
**靠近队头**
![图片](https://spider.nosdn.127.net/fa10338b2c1a87d615ecfe53aca4051a.gif)
**靠队尾**
![图片](https://spider.nosdn.127.net/2902cc2d2c7a269bb9e395a6022d8fac.gif)
**get(index)**
> 也是会先判断index, 不过性能依然不好, 这也是为什么不推荐用for(int i = 0; i < lengh; i++)的方式遍历linkedlist, 而是使用iterator的方式遍历.
![图片](https://spider.nosdn.127.net/60197c5f56d5a2073a25cd8f80ea8d5d.gif)
![图片](https://spider.nosdn.127.net/d5e679c430b67268502430d2ab10b4c5.gif)
**remove(E)**
![图片](https://spider.nosdn.127.net/59e66122b6bd2cd629e374bdc8f6db21.gif)
## ArrayList (数组)
> 底层就是一个数组, 因此按序查找快, 乱序插入, 删除因为涉及到后面元素移位所以性能慢.
![图片](https://spider.nosdn.127.net/e05b9d26043f8178896e17b4391d3668.gif)
**扩容**
> 一般默认容量是10, 扩容后, 会length*1.5倍
![图片](https://spider.nosdn.127.net/989414c062d748deec43243659c142fc.gif)
**remove(E)**
> 循环遍历数组, 判断E是否equals当前元素, 删除性能不如LinkedList.
![图片](https://spider.nosdn.127.net/e4f5257d3e13d253843a5251a69b424e.gif)
## Stack (栈)
> 经典的数据结构, 底层也是数组, 继承自Vector, 先进后出FILO, 默认new Stack()容量为10, 超出自动扩容.
**push(E)**
![图片](https://spider.nosdn.127.net/c134ca0aa4223ba24c335869cd4980a3.gif)
**pop()**
![图片](https://spider.nosdn.127.net/71d100130e475afa924ff3da20b5360b.gif)
## 后缀表达式
> Stack的一个典型应用就是计算表达式如 9 + (3 - 1) * 3 + 10 / 2, 计算机将中缀表达式转为后缀表达式, 再对后缀表达式进行计算.
**中缀转后缀**
- 数字直接输出
- 遇到左括号, 将其入栈
- 遇到右括号, 执行出栈操作,并将出栈的元素输出,直到弹出栈的是左括号,左括号不输出。
- 遇到运算符(加减乘除):弹出所有优先级大于或者等于该运算符的栈顶元素,然后将该运算符入栈
- 最终将栈中的元素依次出栈,输出。
![图片](https://spider.nosdn.127.net/983a4734fbc41e5f6b640220b825d90c.gif)
**计算后缀表达**
- 遇到数字时,将数字压入堆栈
- 遇到运算符时,弹出栈顶的两个数,用运算符对它们做相应的计算, 并将结果入栈
- 重复上述过程直到表达式最右端
- 运算得出的值即为表达式的结果
![图片](https://spider.nosdn.127.net/b2a08026f8f12cae257b7a2320b30d41.gif)
## Queue (队列):
> 与Stack的区别在于, Stack的删除与添加都在队尾进行, 而Queue删除在队头, 添加在队尾.
**ArrayBlockingQueue**
生产消费者中常用的阻塞有界队列, FIFO.
**put(E)**
![图片](https://spider.nosdn.127.net/adba64e4d9c12ddae3db81beb5d861e4.gif)
**put(E) 队列满了**
```java
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == items.length)
notFull.await();
enqueue(e);
} finally {
lock.unlock();
}
```
![图片](https://spider.nosdn.127.net/bd8774c8479dc2cbec0025a79b188431.gif)
**take()**
当元素被取出后, 并没有对数组后面的元素位移, 而是更新takeIndex来指向下一个元素.
takeIndex是一个环形的增长, 当移动到队列尾部时, 会指向0, 再次循环.
```
private E dequeue() {
// assert lock.getHoldCount() == 1;
// assert items[takeIndex] != null;
final Object[] items = this.items;
@SuppressWarnings("unchecked")
E x = (E) items[takeIndex];
items[takeIndex] = null;
if (++takeIndex == items.length)
takeIndex = 0;
count--;
if (itrs != null)
itrs.elementDequeued();
notFull.signal();
return x;
}
```
![图片](https://spider.nosdn.127.net/d15eafe10745453740d7cf74a05a4b8c.gif)
## HashMap (哈希表)
> 最常用的哈希表, 面试的童鞋必备知识了, 内部通过数组 + 单链表的方式实现. jdk8中引入了红黑树对长度 > 8的链表进行优化, 我们另外篇幅再讲.
**put(K, V) 相同hash值**
![图片](https://spider.nosdn.127.net/5a7ce6cf5336a4806f7e9a85df9a9c5f.gif)
**put(K, V) 相同hash值**
![图片](https://spider.nosdn.127.net/0a59eb85f0d5bec62585538617854e68.gif)
**resize 动态扩容**
当map中元素超出设定的阈值后, 会进行resize (length * 2)操作, 扩容过程中对元素一通操作, 并放置到新的位置.
具体操作如下:
- 在jdk7中对所有元素直接rehash, 并放到新的位置.
- 在jdk8中判断元素原hash值新增的bit位是0还是1, 0则索引不变, 1则索引变成"原索引 + oldTable.length".
```
//定义两条链
//原来的hash值新增的bit为0的链,头部和尾部
Node loHead = null, loTail = null;
//原来的hash值新增的bit为1的链,头部和尾部
Node hiHead = null, hiTail = null;
Node next;
//循环遍历出链条链
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
//扩容前后位置不变的链
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
//扩容后位置加上原数组长度的链
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
```
![图片](https://spider.nosdn.127.net/7de710b3093868a688f16387ddbf4f4d.gif)
## LinkedHashMap (双向哈希链表)
> 继承自HashMap, 底层额外维护了一个双向链表来维持数据有序. 可以通过设置accessOrder来实现FIFO(插入有序)或者LRU(访问有序)缓存.
**put(K, V)**
![图片](https://spider.nosdn.127.net/fde4fd50a0d1d74f2e82f8ae1e7ce4d2.gif)
**get(K)**
- accessOrder为false的时候, 直接返回元素就行了, 不需要调整位置.
- accessOrder为true的时候, 需要将最近访问的元素, 放置到队尾.
![图片](https://spider.nosdn.127.net/427758c5d41d70f7399de2a2f52bfe91.gif)
**removeEldestEntry 删除最老的元素**
![图片](https://spider.nosdn.127.net/25e6cae44659453302d9c8bd34c17cb5.gif)