ArrayList跟LinkedList性能测试对比

总结：

        插入：ArrayList比LinkedList快， ArrayList遇到需要扩容时候会影响速度，速度也快于LinkedList；

        查找：ArrayList性能全面优于LinkedList

        删除：LinkedList越靠近头尾速度越快，ArrayList越靠近尾部速度越快。大部分情况下，arrayList速度快于LinkedList

List长度10000000
    ArrayList开始插入：10000000 条
    ArrayList结束插入 用时：2538
    ArrayList头部插入1条：用时4
    ArrayList中间（5000000）插入：用时2
    ArrayList头部删除1条：用时：3
    ArrayList中间（5000000）删除：用时2
    ArrayList尾部删除1条：用时0
    ArrayList查找5000000位置数据： 用时0

    LinkedList开始插入10000000 条
    LinkedList结束插入：5564
    LinkedList头部插入1条： 用时0
    LinkedList中间（5000000）插入1条：用时32
    LinkedList头部删除1条：用时：0
    LinkedList中间（5000000）删除：用时24
    LinkedList尾部删除1条：用时0
    LinkedList查找5000000位置数据： 用时19

List长度20000000
    LinkedList开始插入20000000 条
    LinkedList结束插入：12328
    LinkedList头部插入1条： 用时0
    LinkedList中间（10000000）插入1条：用时29
    LinkedList头部删除1条：用时：0
    LinkedList中间（10000000）删除：用时28
    LinkedList尾部删除1条：用时0
    LinkedList查找10000000位置数据： 用时28
    
    ArrayList开始插入：20000000 条
    ArrayList结束插入 用时：12146
    ArrayList头部插入1条：用时6
    ArrayList中间（10000000）插入：用时4
    ArrayList头部删除1条：用时：8
    ArrayList中间（10000000）删除：用时3
    ArrayList尾部删除1条：用时0
    ArrayList查找10000000位置数据： 用时0
 
List长度30000000
    LinkedList开始插入30000000 条
    LinkedList结束插入：24327
    LinkedList头部插入1条： 用时0
    LinkedList中间（15000000）插入1条：用时104
    LinkedList头部删除1条：用时：0
    LinkedList中间（15000000）删除：用时103
    LinkedList尾部删除1条：用时0
    LinkedList查找15000000位置数据： 用时102
    
    ArrayList开始插入：30000000 条
    ArrayList结束插入 用时：12517
    ArrayList头部插入1条：用时11
    ArrayList中间（15000000）插入：用时5
    ArrayList头部删除1条：用时：10
    ArrayList中间（15000000）删除：用时6
    ArrayList尾部删除1条：用时0
    ArrayList查找15000000位置数据： 用时0

List长度40000000
    LinkedList开始插入40000000 条
    LinkedList结束插入：25347
    LinkedList头部插入1条： 用时0
    LinkedList中间（20000000）插入1条：用时278
    LinkedList头部删除1条：用时：0
    LinkedList中间（20000000）删除：用时277
    LinkedList尾部删除1条：用时0
    LinkedList查找20000000位置数据： 用时279
    
    ArrayList开始插入：40000000 条
    ArrayList结束插入 用时：12494
    ArrayList头部插入1条：用时13
    ArrayList中间（20000000）插入：用时6
    ArrayList头部删除1条：用时：13
    ArrayList中间（20000000）删除：用时6
    ArrayList尾部删除1条：用时0
    ArrayList查找20000000位置数据： 用时0

List长度50000000
    LinkedList开始插入50000000 条
    LinkedList结束插入：41131
    LinkedList头部插入1条： 用时0
    LinkedList中间（25000000）插入1条：用时251
    LinkedList头部删除1条：用时：0
    LinkedList中间（25000000）删除：用时250
    LinkedList尾部删除1条：用时0
    LinkedList查找25000000位置数据： 用时253
    
    ArrayList开始插入：50000000 条
    ArrayList结束插入 用时：27656
    ArrayList头部插入1条：用时16
    ArrayList中间（25000000）插入：用时8
    ArrayList头部删除1条：用时：17
    ArrayList中间（25000000）删除：用时8
    ArrayList尾部删除1条：用时0
    ArrayList查找25000000位置数据： 用时0

List长度60000000
    LinkedList开始插入60000000 条
    LinkedList结束插入：41742
    LinkedList头部插入1条： 用时0
    LinkedList中间（30000000）插入1条：用时181
    LinkedList头部删除1条：用时：0
    LinkedList中间（30000000）删除：用时181
    LinkedList尾部删除1条：用时0
    LinkedList查找30000000位置数据： 用时181
 
    ArrayList开始插入：60000000 条
    ArrayList结束插入 用时：27286
    ArrayList头部插入1条：用时23
    ArrayList中间（30000000）插入：用时12
    ArrayList头部删除1条：用时：23
    ArrayList中间（30000000）删除：用时11
    ArrayList尾部删除1条：用时0
    ArrayList查找30000000位置数据： 用时0

package com.fost.redisdemo.test;

import java.lang.reflect.Array;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * @description: list测试
 * @author: fostl
 * @date: 2023/7/18
 */
public class ListTest {

    public static void main(String[] args) {
        int number1 = 10000000;
        int number2 = 20000000;
        int number3 = 30000000;
        int number4 = 40000000;
        int number5 = 50000000;
        int number6 = 60000000;
//        linkedList(number1);
//        linkedList(number2);
//        linkedList(number3);
//        linkedList(number4);
        linkedList(number5);
        linkedList(number6);

//        arrayList(number1);
//        arrayList(number2);
//        arrayList(number3);
//        arrayList(number4);
//        arrayList(number6);
//        arrayList(number5);
    }

    public static void arrayList(int number) {
        ArrayList<Integer> list = new ArrayList<>();
        LocalDateTime now = LocalDateTime.now();
        System.out.println("ArrayList开始插入：" + number + " 条");
        for (int i = 0; i < number; i++) {
            list.add(i);
        }
        LocalDateTime now1 = LocalDateTime.now();
        System.out.println("ArrayList结束插入 用时：" + (now1.toInstant(ZoneOffset.of("+8")).toEpochMilli() - now.toInstant(ZoneOffset.of("+8")).toEpochMilli()));

        now = LocalDateTime.now();
        list.add(0, -100);
        now1 = LocalDateTime.now();
        System.out.println("ArrayList头部插入1条：用时" + (now1.toInstant(ZoneOffset.of("+8")).toEpochMilli() - now.toInstant(ZoneOffset.of("+8")).toEpochMilli()));

        now = LocalDateTime.now();
        list.add(number / 2, -100);
        now1 = LocalDateTime.now();
        System.out.println("ArrayList中间（" + number / 2 + "）插入：用时" + (now1.toInstant(ZoneOffset.of("+8")).toEpochMilli() - now.toInstant(ZoneOffset.of("+8")).toEpochMilli()));


        now = LocalDateTime.now();
        list.remove(0);
        now1 = LocalDateTime.now();
        System.out.println("ArrayList头部删除1条：用时：" + (now1.toInstant(ZoneOffset.of("+8")).toEpochMilli() - now.toInstant(ZoneOffset.of("+8")).toEpochMilli()));

        now = LocalDateTime.now();
        list.remove(number / 2);
        now1 = LocalDateTime.now();
        System.out.println("ArrayList中间（" + number / 2 + "）删除：用时" + (now1.toInstant(ZoneOffset.of("+8")).toEpochMilli() - now.toInstant(ZoneOffset.of("+8")).toEpochMilli()));

        now = LocalDateTime.now();
        list.remove(list.size() - 1);
        now1 = LocalDateTime.now();
        System.out.println("ArrayList尾部删除1条：用时" + (now1.toInstant(ZoneOffset.of("+8")).toEpochMilli() - now.toInstant(ZoneOffset.of("+8")).toEpochMilli()));


        now = LocalDateTime.now();
        Integer integer = list.get(number / 2);
        now1 = LocalDateTime.now();
        System.out.println("ArrayList查找" + number / 2 + "位置数据： 用时" + (now1.toInstant(ZoneOffset.of("+8")).toEpochMilli() - now.toInstant(ZoneOffset.of("+8")).toEpochMilli()));
    }

    public static void linkedList(int number) {
        List<Integer> list = new LinkedList<>();
        System.out.println("LinkedList开始插入" + number + " 条");
        LocalDateTime now = LocalDateTime.now();
        for (int i = 0; i < number; i++) {
            list.add(i);
        }
        LocalDateTime now1 = LocalDateTime.now();
        System.out.println("LinkedList结束插入：" + (now1.toInstant(ZoneOffset.of("+8")).toEpochMilli() - now.toInstant(ZoneOffset.of("+8")).toEpochMilli()));

        now = LocalDateTime.now();
        list.add(0, -100);
        now1 = LocalDateTime.now();
        System.out.println("LinkedList头部插入1条： 用时" + (now1.toInstant(ZoneOffset.of("+8")).toEpochMilli() - now.toInstant(ZoneOffset.of("+8")).toEpochMilli()));

        now = LocalDateTime.now();
        list.add(number / 2, -100);
        now1 = LocalDateTime.now();
        System.out.println("LinkedList中间（" + number / 2 + "）插入1条：用时" + (now1.toInstant(ZoneOffset.of("+8")).toEpochMilli() - now.toInstant(ZoneOffset.of("+8")).toEpochMilli()));


        now = LocalDateTime.now();
        list.remove(0);
        now1 = LocalDateTime.now();
        System.out.println("LinkedList头部删除1条：用时：" + (now1.toInstant(ZoneOffset.of("+8")).toEpochMilli() - now.toInstant(ZoneOffset.of("+8")).toEpochMilli()));

        now = LocalDateTime.now();
        list.remove(number / 2);
        now1 = LocalDateTime.now();
        System.out.println("LinkedList中间（" + number / 2 + "）删除：用时" + (now1.toInstant(ZoneOffset.of("+8")).toEpochMilli() - now.toInstant(ZoneOffset.of("+8")).toEpochMilli()));

        now = LocalDateTime.now();
        list.remove(list.size() - 1);
        now1 = LocalDateTime.now();
        System.out.println("LinkedList尾部删除1条：用时" + (now1.toInstant(ZoneOffset.of("+8")).toEpochMilli() - now.toInstant(ZoneOffset.of("+8")).toEpochMilli()));


        now = LocalDateTime.now();
        Integer integer = list.get(number / 2);
        now1 = LocalDateTime.now();
        System.out.println("LinkedList查找" + number / 2 + "位置数据： 用时" + (now1.toInstant(ZoneOffset.of("+8")).toEpochMilli() - now.toInstant(ZoneOffset.of("+8")).toEpochMilli()));

    }
}