LinkedList竟然比ArrayList慢了1000多倍？(动图+性能评测)
数组和链表是程序中常用的两种数据结构，也是面试中常考的面试题之一。然而对于很多人来说，只是模糊的记得二者的区别，可能还记得不一定对，并且每次到了面试的时候，都得把这些的概念拿出来背一遍才行，未免有些麻烦。而本文则会从执行过程图以及性能评测等方面入手，让你更加深入的理解和记忆二者的区别，有了这次深入的学习之后，相信会让你记忆深刻。
数组
在开始（性能评测）之前我们先来回顾一下，什么是数组？
数组的定义如下：
数组（Array）是由相同类型的元素（element）的集合所组成的数据结构，分配一块连续的内存来存储。利用元素的索引（index）可以计算出该元素对应的存储地址。
最简单的数据结构类型是一维数组。例如，索引为 0 到 9 的 32 位整数数组，可作为在存储器地址 2000，2004，2008，...2036 中，存储 10个 变量，因此索引为 i 的元素即在存储器中的 2000+4×i 地址。数组第一个元素的存储器地址称为第一地址或基础地址。
简单来说，数组就是由一块连续的内存组成的数据结构。这个概念中有一个关键词“连续”，它反映了数组的一大特点，就是它必须是由一个连续的内存组成的。
数组的数据结构，如下图所示：
数组添加的过程，如下图所示：
数组的优点
数组的“连续”特征决定了它的访问速度很快，因为它是连续存储的，所以这就决定了它的存储位置就是固定的，因此它的访问速度就很快。比如现在有 10 个房间是按照年龄顺序入住的，当我们知道第一房子住的是 20 岁的人之后，那么我们就知道了第二个房子是 21 岁的人，第五个房子是 24 岁的人......等等。
数组的缺点
祸兮福所倚，福兮祸所伏。数组的连续性既有优点又有缺点，优点上面已经说了，而缺点它对内存的要求比较高，必须要找到一块连续的内存才行。
数组的另一个缺点就是插入和删除的效率比较慢，假如我们在数组的非尾部插入或删除一个数据，那么就要移动之后的所有数据，这就会带来一定的性能开销，删除的过程如下图所示：
数组还有一个缺点，它的大小固定，不能动态拓展。
链表
链表是和数组互补的一种数据结构，它的定义如下：
链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针（Pointer）。由于不必须按顺序存储，链表在插入的时候可以达到 O(1) 的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要 O(n) 的时间，而顺序表相应的时间复杂度分别是 O(logn) 和 O(1)。
也就说链表是一个无需连续内存存储的数据结构，链表的元素有两个属性，一个是元素的值，另一个是指针，此指针标记了下一个元素的地址。
链表的数据结构，如下图所示：
链表添加的过程，如下图所示：
链表删除的过程，如下图所示：
链表分类
链表主要分为以下几类：
- 单向链表
- 双向链表
- 循环链表
单向链表
单向链表中包含两个域，一个信息域和一个指针域。这个链接指向列表中的下一个节点，而最后一个节点则指向一个空值，我们上面所展示的链表就是单向链表。
双向链表
双向链表也叫双链表，双向链表中不仅有指向后一个节点的指针，还有指向前一个节点的指针，这样可以从任何一个节点访问前一个节点，当然也可以访问后一个节点，以至整个链表。
双向链表的结构如下图所示：
循环链表
循环链表中第一个节点之前就是最后一个节点，反之亦然。循环链表的无边界使得在这样的链表上设计算法会比普通链表更加容易。
循环链表的结构如下图所示：
为什么会有单、双链表之分？
有人可能会问，既然已经有单向链表了，那为什么还要双向链表呢？双向链表有什么优势呢？
这个就要从链表的删除说起了，如果单向链表要删除元素的话，不但要找到删除的节点，还要找到删除节点的上一个节点（通常称之为前驱），因为需要变更上一个节点中 next 的指针，但又因为它是单向链表，所以在删除的节点中并没有存储上一个节点的相关信息，那么我们就需要再查询一遍链表以找到上一个节点，这样就带来了一定的性能问题，所以就有了双向链表。
链表优点
链表的优点大致可分为以下三个：
- 链表对内存的利用率比较高，无需连续的内存空间，即使有内存碎片，也不影响链表的创建；
- 链表的插入和删除的速度很快，无需像数组一样需要移动大量的元素；
- 链表大小不固定，可以很方便的进行动态扩展。
链表缺点
链表的主要缺点是不能随机查找，必须从第一个开始遍历，查找效率比较低，链表查询的时间复杂度是 O(n)。
性能评测
了解了数组和链表的基础知识之后，接下来我们正式进入性能评测环节。
在正式开始之前，我们先来明确一下测试目标，我们需要测试的点其实只有 6 个：
- 从头部/中间部分/尾部进行添加操作的性能测试；
- 从头部/中间部分/尾部开始查询的性能测试。
因为添加操作和删除操作在执行时间层面基本是一致的，比如数组添加需要移动后面的元素，删除也同样是移动后面的元素；而链表也是如此，添加和删除都是改变自身和相连节点的信息，因此我们就把添加和删除的测试合二为一，用添加操作来进行测试。
测试说明：
- 在 Java 语言中，数组的代表为
ArrayList，而链表的代表为LinkedList，因此我们就用这两个对象来进行测试； - 本文我们将使用 Oracle 官方推荐 JMH 框架来进行测试，点击查看更多关于 JMH 的内容；
- 本文测试环境是 JDK 1.8、MacMini、Idea 2020.1。
1.头部添加性能测试
import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.concurrent.TimeUnit;
@BenchmarkMode(Mode.AverageTime) // 测试完成时间
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS) // 预热次数和时间
@Measurement(iterations = 5, time = 5, timeUnit = TimeUnit.SECONDS) // 测试次数和时间
@Fork(1) // fork 1 个线程
@State(Scope.Thread)
public class ArrayOptimizeTest {
private static final int maxSize = 1000; // 测试循环次数
private static final int operationSize = 100; // 操作次数
private static ArrayList<Integer> arrayList;
private static LinkedList<Integer> linkedList;
public static void main(String[] args) throws RunnerException {
// 启动基准测试
Options opt = new OptionsBuilder()
.include(ArrayOptimizeTest.class.getSimpleName()) // 要导入的测试类
.build();
new Runner(opt).run(); // 执行测试
}
@Setup
public void init() {
// 启动执行事件
arrayList = new ArrayList<Integer>();
linkedList = new LinkedList<Integer>();
for (int i = 0; i < maxSize; i++) {
arrayList.add(i);
linkedList.add(i);
}
}
@Benchmark
public void addArrayByFirst(Blackhole blackhole) {
for (int i = 0; i < +operationSize; i++) {
arrayList.add(i, i);
}
// 为了避免 JIT 忽略未被使用的结果计算
blackhole.consume(arrayList);
}
@Benchmark
public void addLinkedByFirst(Blackhole blackhole) {
for (int i = 0; i < +operationSize; i++) {
linkedList.add(i, i);
}
// 为了避免 JIT 忽略未被使用的结果计算
blackhole.consume(linkedList);
}
}
复制代码从以上代码可以看出，在测试之前，我们先将 ArrayList 和 LinkedList 进行数据初始化，再从头部开始添加 100 个元素，执行结果如下：
从以上结果可以看出，LinkedList 的平均执行（完成）时间比 ArrayList 平均执行时间快了约 216 倍。
2.中间添加性能测试
import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.concurrent.TimeUnit;
@BenchmarkMode(Mode.AverageTime) // 测试完成时间
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS) // 预热次数和时间
@Measurement(iterations = 5, time = 5, timeUnit = TimeUnit.SECONDS) // 测试次数和时间
@Fork(1) // fork 1 个线程
@State(Scope.Thread)
public class ArrayOptimizeTest {
private static final int maxSize = 1000; // 测试循环次数
private static final int operationSize = 100; // 操作次数
private static ArrayList<Integer> arrayList;
private static LinkedList<Integer> linkedList;
public static void main(String[] args) throws RunnerException {
// 启动基准测试
Options opt = new OptionsBuilder()
.include(ArrayOptimizeTest.class.getSimpleName()) // 要导入的测试类
.build();
new Runner(opt).run(); // 执行测试
}
@Setup
public void init() {
// 启动执行事件
arrayList = new ArrayList<Integer>();
linkedList = new LinkedList<Integer>();
for (int i = 0; i < maxSize; i++) {
arrayList.add(i);
linkedList.add(i);
}
}
@Benchmark
public void addArrayByMiddle(Blackhole blackhole) {
int startCount = maxSize / 2; // 计算中间位置
// 中间部分进行插入
for (int i = startCount; i < (startCount + operationSize); i++) {
arrayList.add(i, i);
}
// 为了避免 JIT 忽略未被使用的结果计算
blackhole.consume(arrayList);
}
@Benchmark
public void addLinkedByMiddle(Blackhole blackhole) {
int startCount = maxSize / 2; // 计算中间位置
// 中间部分进行插入
for (int i = startCount; i < (startCount + operationSize); i++) {
linkedList.add(i, i);
}
// 为了避免 JIT 忽略未被使用的结果计算
blackhole.consume(linkedList);
}
}
复制代码从以上代码可以看出，在测试之前，我们先将 ArrayList 和 LinkedList 进行数据初始化，再从中间开始添加 100 个元素，执行结果如下：
从上述结果可以看出，LinkedList 的平均执行时间比 ArrayList 平均执行时间快了约 54 倍。
3.尾部添加性能测试
import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.concurrent.TimeUnit;
@BenchmarkMode(Mode.AverageTime) // 测试完成时间
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS) // 预热次数和时间
@Measurement(iterations = 5, time = 5, timeUnit = TimeUnit.SECONDS) // 测试次数和时间
@Fork(1) // fork 1 个线程
@State(Scope.Thread)
public class ArrayOptimizeTest {
private static final int maxSize = 1000; // 测试循环次数
private static final int operationSize = 100; // 操作次数
private static ArrayList<Integer> arrayList;
private static LinkedList<Integer> linkedList;
public static void main(String[] args) throws RunnerException {
// 启动基准测试
Options opt = new OptionsBuilder()
.include(ArrayOptimizeTest.class.getSimpleName()) // 要导入的测试类
.build();
new Runner(opt).run(); // 执行测试
}
@Setup
public void init() {
// 启动执行事件
arrayList = new ArrayList<Integer>();
linkedList = new LinkedList<Integer>();
for (int i = 0; i < maxSize; i++) {
arrayList.add(i);
linkedList.add(i);
}
}
@Benchmark
public void addArrayByEnd(Blackhole blackhole) {
int startCount = maxSize - 1 - operationSize;
for (int i = startCount; i < (maxSize - 1); i++) {
arrayList.add(i, i);
}
// 为了避免 JIT 忽略未被使用的结果计算
blackhole.consume(arrayList);
}
@Benchmark
public void addLinkedByEnd(Blackhole blackhole) {
int startCount = maxSize - 1 - operationSize;
for (int i = startCount; i < (maxSize - 1); i++) {
linkedList.add(i, i);
}
// 为了避免 JIT 忽略未被使用的结果计算
blackhole.consume(linkedList);
}
}
复制代码以上程序的执行结果为：
从上述结果可以看出，LinkedList 的平均执行时间比 ArrayList 平均执行时间快了约 32 倍。
4.头部查询性能评测
import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.concurrent.TimeUnit;
@BenchmarkMode(Mode.AverageTime) // 测试完成时间
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS) // 预热次数和时间
@Measurement(iterations = 5, time = 5, timeUnit = TimeUnit.SECONDS) // 测试次数和时间
@Fork(1) // fork 1 个线程
@State(Scope.Thread)
public class ArrayOptimizeTest {
private static final int maxSize = 1000; // 测试循环次数
private static final int operationSize = 100; // 操作次数
private static ArrayList<Integer> arrayList;
private static LinkedList<Integer> linkedList;
public static void main(String[] args) throws RunnerException {
// 启动基准测试
Options opt = new OptionsBuilder()
.include(ArrayOptimizeTest.class.getSimpleName()) // 要导入的测试类
.build();
new Runner(opt).run(); // 执行测试
}
@Setup
public void init() {
// 启动执行事件
arrayList = new ArrayList<Integer>();
linkedList = new LinkedList<Integer>();
for (int i = 0; i < maxSize; i++) {
arrayList.add(i);
linkedList.add(i);
}
}
@Benchmark
public void findArrayByFirst() {
for (int i = 0; i < operationSize; i++) {
arrayList.get(i);
}
}
@Benchmark
public void findLinkedyByFirst() {
for (int i = 0; i < operationSize; i++) {
linkedList.get(i);
}
}
}
复制代码以上程序的执行结果为：
从上述结果可以看出，从头部查询 100 个元素时 ArrayList 的平均执行时间比 LinkedList 平均执行时间快了约 1990 倍。
5.中间查询性能评测
import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.concurrent.TimeUnit;
@BenchmarkMode(Mode.AverageTime) // 测试完成时间
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS) // 预热次数和时间
@Measurement(iterations = 5, time = 5, timeUnit = TimeUnit.SECONDS) // 测试次数和时间
@Fork(1) // fork 1 个线程
@State(Scope.Thread)
public class ArrayOptimizeTest {
private static final int maxSize = 1000; // 测试循环次数
private static final int operationSize = 100; // 操作次数
private static ArrayList<Integer> arrayList;
private static LinkedList<Integer> linkedList;
public static void main(String[] args) throws RunnerException {
// 启动基准测试
Options opt = new OptionsBuilder()
.include(ArrayOptimizeTest.class.getSimpleName()) // 要导入的测试类
.build();
new Runner(opt).run(); // 执行测试
}
@Setup
public void init() {
// 启动执行事件
arrayList = new ArrayList<Integer>();
linkedList = new LinkedList<Integer>();
for (int i = 0; i < maxSize; i++) {
arrayList.add(i);
linkedList.add(i);
}
}
@Benchmark
public void findArrayByMiddle() {
int startCount = maxSize / 2;
int endCount = startCount + operationSize;
for (int i = startCount; i < endCount; i++) {
arrayList.get(i);
}
}
@Benchmark
public void findLinkedyByMiddle() {
int startCount = maxSize / 2;
int endCount = startCount + operationSize;
for (int i = startCount; i < endCount; i++) {
linkedList.get(i);
}
}
}
复制代码以上程序的执行结果为：
从上述结果可以看出，从中间查询 100 个元素时 ArrayList 的平均执行时间比 LinkedList 平均执行时间快了约 28089 倍，真是恐怖。
6.尾部查询性能评测
import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.concurrent.TimeUnit;
@BenchmarkMode(Mode.AverageTime) // 测试完成时间
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS) // 预热次数和时间
@Measurement(iterations = 5, time = 5, timeUnit = TimeUnit.SECONDS) // 测试次数和时间
@Fork(1) // fork 1 个线程
@State(Scope.Thread)
public class ArrayOptimizeTest {
private static final int maxSize = 1000; // 测试循环次数
private static final int operationSize = 100; // 操作次数
private static ArrayList<Integer> arrayList;
private static LinkedList<Integer> linkedList;
public static void main(String[] args) throws RunnerException {
// 启动基准测试
Options opt = new OptionsBuilder()
.include(ArrayOptimizeTest.class.getSimpleName()) // 要导入的测试类
.build();
new Runner(opt).run(); // 执行测试
}
@Setup
public void init() {
// 启动执行事件
arrayList = new ArrayList<Integer>();
linkedList = new LinkedList<Integer>();
for (int i = 0; i < maxSize; i++) {
arrayList.add(i);
linkedList.add(i);
}
}
@Benchmark
public void findArrayByEnd() {
for (int i = (maxSize - operationSize); i < maxSize; i++) {
arrayList.get(i);
}
}
@Benchmark
public void findLinkedyByEnd() {
for (int i = (maxSize - operationSize); i < maxSize; i++) {
linkedList.get(i);
}
}
}
复制代码以上程序的执行结果为：
从上述结果可以看出，从尾部查询 100 个元素时 ArrayList 的平均执行时间比 LinkedList 平均执行成时间快了约 1839 倍。
7.扩展添加测试
接下来我们再来测试一下，正常情况下我们从头开始添加数组和链表的性能对比，测试代码如下：
import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.infra.Blackhole;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.concurrent.TimeUnit;
@BenchmarkMode(Mode.AverageTime) // 测试完成时间
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS) // 预热次数和时间
@Measurement(iterations = 5, time = 5, timeUnit = TimeUnit.SECONDS) // 测试次数和时间
@Fork(1) // fork 1 个线程
@State(Scope.Thread)
public class ArrayOptimizeTest {
private static final int maxSize = 1000; // 测试循环次数
private static ArrayList<Integer> arrayList;
private static LinkedList<Integer> linkedList;
public static void main(String[] args) throws RunnerException {
// 启动基准测试
Options opt = new OptionsBuilder()
.include(ArrayOptimizeTest.class.getSimpleName()) // 要导入的测试类
.build();
new Runner(opt).run(); // 执行测试
}
@Benchmark
public void addArray(Blackhole blackhole) { // 中间删数组表
arrayList = new ArrayList<Integer>();
for (int i = 0; i < maxSize; i++) {
arrayList.add(i);
}
// 为了避免 JIT 忽略未被使用的结果计算
blackhole.consume(arrayList);
}
@Benchmark
public void addLinked(Blackhole blackhole) { // 中间删除链表
linkedList = new LinkedList<Integer>();
for (int i = 0; i < maxSize; i++) {
linkedList.add(i);
}
// 为了避免 JIT 忽略未被使用的结果计算
blackhole.consume(linkedList);
}
}
复制代码以上程序的执行结果为：
接下来，我们将添加的次数调至 1w，测试结果如下：
最后，我们再将添加次数调至 10w，测试结果如下：
从以上结果可以看出在正常情况下，从头部依次开始添加元素时，他们性能差别不大。
总结
本文我们介绍了数组的概念以及它的优缺点，同时还介绍了单向链表、双向链表及循环链表的概念以及链表的优缺点。我们在最后的评测中可以看出，当我们正常从头部依次添加元素时，链表和数组的性能差不不大。但当数据初始化完成之后，我们再进行插入操作时，尤其是从头部插入时，因为数组要移动之后的所有元素，因此性能要比链表低很多；但在查询时性能刚好相反，因为链表要遍历查询，并且 LinkedList 是双向链表，所以在中间查询时性能要比数组查询慢了上万倍（查询 100 个元素），而两头查询（首部和尾部）时，链表也比数组慢了将近 1000 多倍（查询 100 个元素），因此在查询比较多的场景中，我们要尽量使用数组，而在添加和删除操作比较多时，我们应该使用链表结构。
数组和链表的操作时间复杂度，如下表所示：
| 数组 | 链表 | |
|---|---|---|
| 查询 | O(1) | O(n) |
| 插入 | O(n) | O(1) |
| 删除 | O(n) | O(1) |
LinkedList竟然比ArrayList慢了1000多倍？(动图+性能评测)的更多相关文章
- LinkedList类 和ArrayList类
1)LinkedList类 LinkedList实现了List接口,允许null元素.此外LinkedList提供额外的get,remove,insert方法在 LinkedList的首部或尾部.这 ...
- Java中ArrayList和LinkedList区别、ArrayList和Vector的区别
一般大家都知道ArrayList和LinkedList的大致区别: 1.ArrayList是实现了基于动态数组的数据结构,LinkedList基于链表的数据结构. 2.对于随机访问get和set,Ar ...
- 解决Notice错误，性能竟然提升了1000多倍！
先说PHP的deprecated错误的性能问题 最近刚刚完成了一个项目,在测试完基本功能后,我们就发布到线上.结果上线不久就发现产生了大量的错误,如下图: 一看都是PHP的Deprecated错误,是 ...
- 都说新的Arraylist 扩容是(1.5倍+1) 看了1.8的源代码发现不是这么回事
都说新的Arraylist 扩容是(1.5倍+1) 看了1.8的源代码发现不是这么回事 就用下面这段代码在jdk的三个版本运行看了下效果 import java.lang.reflect.Field; ...
- 分享知识-快乐自己：都说新的Arraylist 扩容是(1.5倍+1) 看了1.8的源代码发现不是这么回事
都说新的Arraylist 扩容是(1.5倍+1) 看了1.8的源代码发现不是这么回事 就用下面这段代码在jdk的三个版本运行看了下效果: import java.lang.reflect.Field ...
- coding++：都说新的Arraylist 扩容是(1.5倍+1) 看了1.8的源代码发现不是这么回事
都说新的Arraylist 扩容是(1.5倍+1) 看了1.8的源代码发现不是这么回事 就用下面这段代码在jdk的三个版本运行看了下效果: import java.lang.reflect.Fiel ...
- 面经手册 · 第8篇《LinkedList插入速度比ArrayList快？你确定吗？》
作者:小傅哥 博客:https://bugstack.cn 沉淀.分享.成长,让自己和他人都能有所收获! 一.前言 你以为考你个数据结构是要造火箭? 汽车75马力就够奔跑了,那你怎么还想要2.0涡轮+ ...
- MySQL“被动”性能优化汇总！
年少不知优化苦,遇坑方知优化难. --村口王大爷 本文内容导图如下: 我之前有很多文章都在讲性能优化的问题,比如下面这些: <switch 的性能提升了 3 倍,我只用了这一招!> < ...
- 你真的说的清楚ArrayList和LinkedList的区别吗
参见java面试的程序员,十有八九会遇到ArrayList和LinkedList的区别?相信很多看到这个问题的人,都能回答个一二.但是,真正搞清楚的话,还得花费一番功夫. 下面我从4个方面来谈谈这个问 ...
随机推荐
- 蓝桥杯 试题 历届试题 填字母游戏 博弈+dfs剪枝
问题描述 小明经常玩 LOL 游戏上瘾,一次他想挑战K大师,不料K大师说: “我们先来玩个空格填字母的游戏,要是你不能赢我,就再别玩LOL了”. K大师在纸上画了一行n个格子,要小明和他交替往其中填入 ...
- python 日期、时间
1.字符类型的时间 转为 时间数组 t1 = '2013-10-10 23:40:00'timeArray = time.strptime(t1, "%Y-%m-%d %H:%M:%S&qu ...
- Ubuntu 18.04上交叉编译华硕路由器RT-AC88U的梅林384.15版本
研究了半天官方wiki上的文档,最后却找到这个一键脚本.手动试了一下,丝般顺滑,成功编译出RT-AC88U的梅林固件384.15版本.也可以编译其他路由器型号的固件. 不过这个脚本比较暴力,上来就把/ ...
- afert和b的伪类画三角形
/* 提示信息 */ .content-tishi{ width: 6.93rem; margin: 0 auto; background: #e9eaea; display: flex; flex- ...
- JZOJ 4611. 【NOI2016模拟7.11】接水问题 （贪心+A*+可持久化线段树）
Description: https://gmoj.net/senior/#main/show/4611 题解: 先把A从大到小排序,最小的由排序不等式显然. 考虑类似第k短路的A*的做法. 定义状态 ...
- 获取cookie里面的sessionid
做接口的时候我们需要获取一个令牌,类似于token以及sessionid这样的签名,也可以说是一个令牌. import urllib.request, urllib.parse, urllib.err ...
- Android中的多进程、多线程
前面几篇总结了进程.线程相关的知识.这里总结下关于Android中的多进程.多线程及其使用. 这里总结的Android中的多进程.多线程也是一个基础,可扩展的很多. Android中多进程 常见的几种 ...
- Linux内核进程调度overview(1)
一.概述 决定何时.如何选择一个新进程运行的这组规则叫做:调度策略(scheduling policy). Linux的调度是基于分时技术(time sharing):多个进程以“时间多路复用”方式运 ...
- Java实现 LeetCode 802 找到最终的安全状态 （DFS）
802. 找到最终的安全状态 在有向图中, 我们从某个节点和每个转向处开始, 沿着图的有向边走. 如果我们到达的节点是终点 (即它没有连出的有向边), 我们停止. 现在, 如果我们最后能走到终点,那么 ...
- Java实现 LeetCode 495 提莫攻击
495. 提莫攻击 在<英雄联盟>的世界中,有一个叫 "提莫" 的英雄,他的攻击可以让敌方英雄艾希(编者注:寒冰射手)进入中毒状态.现在,给出提莫对艾希的攻击时间序列和 ...