ArrayList和LinkedList该如何选择？ --《JAVA编程思想》 70

最新推荐文章于 2025-10-31 21:01:55 发布
原创 最新推荐文章于 2025-10-31 21:01:55 发布 · 777 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言 #后端 #list #性能

本文通过实测对比，展示了ArrayList和LinkedList在顺序添加、中部添加、头部添加、随机添加、迭代遍历、随机访问、随机更新和随机移除等操作中的性能差异，揭示了ArrayList在随机访问方面的优势和LinkedList在遍历和拓展上的高效性。

我们在实现 List 时，通常会考虑使用 ArrayList 和 LinkedList ,Vector 属于遗留代码类库，已不推荐使用。

下面，我们将以 List 的各种常用操作作为测试指标，验证 ArrayList 和 LinkedList 两者的性能指标。

目录

0.准备工作

在此之前，先定义好测试模板，更好的帮助我们编写测试代码；

ContainerTest 为一个通用的测试基类，用泛型来兼容 ArrayList 和 LinkedList；再定义抽象方法 test()，便于我们自定义各种需要测试的方法。

public abstract class ContainerTest<T extends List> {

    private T list;


    public abstract long test();

    public ContainerTest(T list) {
        this.list = list;
    }

    public T getList() {
        return list;
    }

    public void setList(T list) {
        this.list = list;
    }
    
}

与此同时，拥有一个生成测试数据的工具类 InitIntegerList 也是相当的有必要；

public class InitIntegerList {

    public static <T extends List> T initList(T list, int size) {
        list.clear();
        for (int i = 0; i < size; i++) {
            list.add(i);
        }
        return list;
    }

}

接下来，编写提供各种测试功能 ListPerformanceTest 工具类。其中 initList() 用于生成测试数据；displayHead() 打印测试信息的表头；

public class ListPerformanceTest {


    public static <T extends List> T initList(T list, int size) {
        List initList = InitIntegerList.initList(list, size);
        list.addAll(initList);
        return list;
    }

    public static <T> void displayHead(T t, String methodName) {
        System.out.println(t.getClass().getSimpleName() + "\t" + methodName);
        System.out.println("集合长度\t操作次数\t平均时间");
    }

后续编写的方法都是在 ListPerformanceTest 内运行，重复的部分不再贴出来了。每次执行测试方法后，打印方法执行次数、集合长度、平均操作时间作为参考，在随机测试方面，指定 Random 随机种子，保证每次随机取得元素的一致性。

1.顺序添加

    /**
     *
     * @param list 测试容器
     * @param loops 循环次数
     * @param <T> 指定继承自 List 的泛型
     */
   public static <T extends List> void add(T list, int loops) {
        ContainerTest<T> testList = new ContainerTest<T>(list) {
            @Override
            public long test() {
                long startTime = System.nanoTime();
                T t = getList();
                for (int i = 0; i < loops; i++) {
                    t.add(i);
                }
                return System.nanoTime() - startTime;
            }
        };
        long operateTime = testList.test();
        long avg = operateTime / loops;
        System.out.println(list.size() + "\t" + loops + "\t" + avg);
    }

    public static void main(String[] args) {
        Integer[] integers = {10000, 30000, 50000};
        ArrayList<Integer> arrayList = new ArrayList<>();
        displayHead(arrayList, "顺序添加");
        for (int i = 0; i < integers.length; i++) {
            add(arrayList, integers[i]);
        }
        System.out.println();
        LinkedList<Integer> linkedList = new LinkedList<>();
        displayHead(linkedList, "顺序添加");
        for (int i = 0; i < integers.length; i++) {
            add(linkedList, integers[i]);
        }
    }

ArrayList	顺序添加
集合长度	操作次数	平均时间
10000	10000	149
40000	30000	70
90000	50000	51

LinkedList	顺序添加
集合长度	操作次数	平均时间
10000	10000	60
40000	30000	31
90000	50000	27

2.中部添加

    /**
     *
     * @param list 测试容器
     * @param loops 循环次数
     * @param size 集合长度
     * @param <T> 指定继承自 List 的泛型
     */
    public static <T extends List> void addHalf(T list, int loops, int size) {
        ContainerTest<T> testList = new ContainerTest<T>(list) {
            @Override
            public long test() {
                long startTime = System.nanoTime();
                T t = getList();
                for (int i = 0; i < loops; i++) {
                    t.add(size / 2, i);
                }
                return System.nanoTime() - startTime;
            }
        };
        long operateTime = testList.test();
        long avg = operateTime / loops;
        System.out.println(size + "\t" + loops + "\t" + avg);
    }


    public static void main(String[] args) {
        Integer[][] integers = {{100, 10000}, {200, 30000}, {300, 50000}};
        ArrayList<Integer> arrayList = new ArrayList<>();
        displayHead(arrayList, "中部添加");
        for (int i = 0; i < integers.length; i++) {
            arrayList = initList(new ArrayList(), integers[i][1]);
            addHalf(arrayList, integers[i][0], integers[i][1]);
        }
        System.out.println();
        LinkedList<Integer> linkedList = new LinkedList<>();
        displayHead(linkedList, "中部添加");
        for (int i = 0; i < integers.length; i++) {
            linkedList = initList(new LinkedList(), integers[i][1]);
            addHalf(linkedList, integers[i][0], integers[i][1]);
        }
    }


ArrayList	中部添加
集合长度	操作次数	平均时间
10000	100	2061
30000	200	5779
50000	300	5098

LinkedList	中部添加
集合长度	操作次数	平均时间
10000	100	17215
30000	200	30818
50000	300	32258

3.头部添加

    /**
     *
     * @param list 测试容器
     * @param loops 循环次数
     * @param size 集合长度
     * @param <T> 指定继承自 List 的泛型
     */
    public static <T extends List> void addHead(T list, int loops, int size) {
        ContainerTest<T> testList = new ContainerTest<T>(list) {
            @Override
            public long test() {
                long startTime = System.nanoTime();
                T t = getList();
                for (int i = 0; i < loops; i++) {
                    t.add(0, i);
                }
                return System.nanoTime() - startTime;
            }
        };
        long operateTime = testList.test();
        long avg = operateTime / loops;
        System.out.println(size + "\t" + loops + "\t" + avg);
    }

    public static void main(String[] args) {
        Integer[][] integers = {{100, 10000}, {200, 30000}, {300, 50000}};
        ArrayList<Integer> arrayList = new ArrayList<>();
        displayHead(arrayList, "头部添加");
        for (int i = 0; i < integers.length; i++) {
            arrayList = initList(new ArrayList(), integers[i][1]);
            addHead(arrayList, integers[i][0], integers[i][1]);
        }
        System.out.println();
        LinkedList<Integer> linkedList = new LinkedList<>();
        displayHead(linkedList, "头部添加");
        for (int i = 0; i < integers.length; i++) {
            linkedList = initList(new LinkedList(), integers[i][1]);
            addHead(linkedList, integers[i][0], integers[i][1]);
        }
    }

ArrayList	头部添加
集合长度	操作次数	平均时间
10000	100	4900
30000	200	11711
50000	300	10227

LinkedList	头部添加
集合长度	操作次数	平均时间
10000	100	419
30000	200	517
50000	300	274

4.随机添加

    /**
     *
     * @param list 测试容器
     * @param loops 循环次数
     * @param size 集合长度
     * @param <T> 指定继承自 List 的泛型
     */
    public static <T extends List> void addRandom(T list, int loops, int size) {
        ContainerTest<T> testList = new ContainerTest<T>(list) {
            @Override
            public long test() {
                Random random = new Random(47);
                long startTime = System.nanoTime();
                T t = getList();
                for (int i = 0; i < loops; i++) {
                    t.add(random.nextInt(size), i);
                }
                return System.nanoTime() - startTime;
            }
        };
        long operateTime = testList.test();
        long avg = operateTime / loops;
        System.out.println(size + "\t" + loops + "\t" + avg);
    }
    
    public static void main(String[] args) {
        Integer[][] integers = {{100, 10000}, {200, 30000}, {300, 50000}};
        ArrayList<Integer> arrayList = new ArrayList<>();
        displayHead(arrayList, "随机添加");
        for (int i = 0; i < integers.length; i++) {
            arrayList = initList(new ArrayList(), integers[i][1]);
            addRandom(arrayList, integers[i][0], integers[i][1]);
        }
        System.out.println();
        LinkedList<Integer> linkedList = new LinkedList<>();
        displayHead(linkedList, "随机添加");
        for (int i = 0; i < integers.length; i++) {
            linkedList = initList(new LinkedList(), integers[i][1]);
            addRandom(linkedList, integers[i][0], integers[i][1]);
        }
    }

ArrayList	随机添加
集合长度	操作次数	平均时间
10000	100	3934
30000	200	6010
50000	300	6568

LinkedList	随机添加
集合长度	操作次数	平均时间
10000	100	12981
30000	200	15777
50000	300	17045

5.迭代遍历

    /**
     *
     * @param list 测试容器
     * @param size 集合长度
     * @param <T> 指定继承自 List 的泛型
     */
    public static <T extends List> void iter(T list, int size) {
        ContainerTest<T> testList = new ContainerTest<T>(list) {
            @Override
            public long test() {
                long startTime = System.nanoTime();
                T t = getList();
                ListIterator listIterator = t.listIterator();
                while (listIterator.hasNext()) {
                    listIterator.next();
                }
                return System.nanoTime() - startTime;
            }
        };
        long operateTime = testList.test();
        long avg = operateTime / size;
        System.out.println(size + "\t" + size + "\t" + avg);
    }

    public static void main(String[] args) {
        Integer[] integers = {10000, 30000, 50000};
        ArrayList<Integer> arrayList = new ArrayList<>();
        displayHead(arrayList, "迭代遍历");
        for (int i = 0; i < integers.length; i++) {
            arrayList = initList(arrayList, integers[i]);
            iter(arrayList, integers[i]);
        }
        System.out.println();
        LinkedList<Integer> linkedList = new LinkedList<>();
        displayHead(linkedList, "迭代遍历");
        for (int i = 0; i < integers.length; i++) {
            linkedList = initList(linkedList, integers[i]);
            iter(linkedList, integers[i]);
        }
    }

ArrayList	迭代遍历
集合长度	操作次数	平均时间
10000	10000	108
30000	30000	57
50000	50000	37

LinkedList	迭代遍历
集合长度	操作次数	平均时间
10000	10000	72
30000	30000	11
50000	50000	12

6.随机访问

    /**
     *
     * @param list 测试容器
     * @param loops 循环次数
     * @param size 集合长度
     * @param <T> 指定继承自 List 的泛型
     */
    public static <T extends List> void get(T list, int loops, int size) {
        ContainerTest<T> testList = new ContainerTest<T>(list) {
            @Override
            public long test() {
                long startTime = System.nanoTime();
                T t = getList();
                Random random = new Random(47);
                for (int i = 0; i < loops; i++) {
                    t.get(random.nextInt(size));
                }
                return System.nanoTime() - startTime;
            }
        };
        long operateTime = testList.test();
        long avg = operateTime / loops;
        System.out.println(size + "\t" + loops + "\t" + avg);
    }

    public static void main(String[] args) {
        Integer[][] integers = {{100, 10000}, {200, 30000}, {300, 50000}};
        ArrayList<Integer> arrayList = new ArrayList<>();
        displayHead(arrayList, "随机访问");
        for (int i = 0; i < integers.length; i++) {
            arrayList = initList(new ArrayList(), integers[i][1]);
            get(arrayList, integers[i][0], integers[i][1]);
        }
        System.out.println();
        LinkedList<Integer> linkedList = new LinkedList<>();
        displayHead(linkedList, "随机访问");
        for (int i = 0; i < integers.length; i++) {
            linkedList = initList(new LinkedList(), integers[i][1]);
            get(linkedList, integers[i][0], integers[i][1]);
        }
    }

ArrayList	随机访问
集合长度	操作次数	平均时间
10000	100	3327
30000	200	494
50000	300	98

LinkedList	随机访问
集合长度	操作次数	平均时间
10000	100	13331
30000	200	18803
50000	300	16241

7.随机更新

    /**
     *
     * @param list 测试容器
     * @param loops 循环次数
     * @param size 集合长度
     * @param <T> 指定继承自 List 的泛型
     */
    public static <T extends List> void set(T list, int loops, int size) {
        ContainerTest<T> testList = new ContainerTest<T>(list) {
            @Override
            public long test() {
                long startTime = System.nanoTime();
                T t = getList();
                Random random = new Random(47);
                for (int i = 0; i < loops; i++) {
                    t.set(random.nextInt(size), i);
                }
                return System.nanoTime() - startTime;
            }
        };
        long operateTime = testList.test();
        long avg = operateTime / loops;
        System.out.println(size + "\t" + loops + "\t" + avg);
    }

    public static void main(String[] args) {
        Integer[][] integers = {{100, 10000}, {200, 30000}, {300, 50000}};
        ArrayList<Integer> arrayList = new ArrayList<>();
        displayHead(arrayList, "随机更新");
        for (int i = 0; i < integers.length; i++) {
            arrayList = initList(new ArrayList(), integers[i][1]);
            set(arrayList, integers[i][0], integers[i][1]);
        }
        System.out.println();
        LinkedList<Integer> linkedList = new LinkedList<>();
        displayHead(linkedList, "随机更新");
        for (int i = 0; i < integers.length; i++) {
            linkedList = initList(new LinkedList(), integers[i][1]);
            set(linkedList, integers[i][0], integers[i][1]);
        }
    }


ArrayList	随机更新
集合长度	操作次数	平均时间
10000	100	4996
30000	200	538
50000	300	197

LinkedList	随机更新
集合长度	操作次数	平均时间
10000	100	14090
30000	200	15057
50000	300	16582

8.随机移除

    /**
     *
     * @param list 测试容器
     * @param loops 循环次数
     * @param size 集合长度
     * @param <T> 指定继承自 List 的泛型
     */
    public static <T extends List> void remove(T list, int loops, int size) {
        ContainerTest<T> testList = new ContainerTest<T>(list) {
            @Override
            public long test() {
                long startTime = System.nanoTime();
                T t = getList();
                Random random = new Random(47);
                for (int i = 0; i < loops; i++) {
                    t.remove(random.nextInt(size - loops));
                }
                return System.nanoTime() - startTime;
            }
        };
        long operateTime = testList.test();
        long avg = operateTime / loops;
        System.out.println(size + "\t" + loops + "\t" + avg);
    }

    public static void main(String[] args) {
        Integer[][] integers = {{100, 10000}, {200, 30000}, {300, 50000}};
        ArrayList<Integer> arrayList = new ArrayList<>();
        displayHead(arrayList, "随机移除");
        for (int i = 0; i < integers.length; i++) {
            arrayList = initList(new ArrayList(), integers[i][1]);
            remove(arrayList, integers[i][0], integers[i][1]);
        }
        System.out.println();
        LinkedList<Integer> linkedList = new LinkedList<>();
        displayHead(linkedList, "随机移除");
        for (int i = 0; i < integers.length; i++) {
            linkedList = initList(new LinkedList(), integers[i][1]);
            remove(linkedList, integers[i][0], integers[i][1]);
        }
    }

ArrayList	随机移除
集合长度	操作次数	平均时间
10000	100	6140
30000	200	6284
50000	300	6349

LinkedList	随机移除
集合长度	操作次数	平均时间
10000	100	11941
30000	200	20445
50000	300	16182

9.测试结果汇总

测试项目ArrayListLinkedList
顺序添加低高
中部添加高低
头部添加低高
随机添加高低
迭代遍历低高
随机访问高低
随机更新高低
随机移除高低

ArrayList 底层为数组结构，故其随机访问性能高；LinkedList 为双向链表结构，拥有良好的伸缩拓展性，当在遍历和向首尾两端拓展时，性能优于 ArrayList 。

本次分享至此结束，希望本文对你有所帮助，若能点亮下方的点赞按钮，在下感激不尽，谢谢您的【精神支持】。

若有任何疑问，也欢迎与我交流，若存在不足之处，也欢迎各位指正！

深入解析：ArrayList与LinkedList的抉择之道
m0_51176516的博客
05-21 1908
ArrayList和LinkedList在Java集合框架中各自扮演着重要角色，它们的选择取决于具体的使用场景。ArrayList基于动态数组实现，随机访问效率高，适用于需要频繁访问元素或预知元素数量的场景；而LinkedList基于双向链表实现，插入和删除操作（特别是头尾操作）效率高，适用于需要频繁进行元素插入和删除的场景。 在选择时，除了考虑数据结构本身的特性外，还需要考虑数据量和操作类型对性能的影响。对于大数据量或高并发场景，可能还需要考虑线程安全性和内存占用等因素。 ...
thinking-in-java-zh:Java 编程思想
05-14
在Java编程思想中，读者可以学习到以下关键知识点： 1. **基础语法**：包括变量、数据类型、运算符、流程控制（如if语句、switch语句、循环）、方法、类和对象等基本元素。这些是所有Java程序员必须掌握的基础。 2...
ArrayList与LinkedList的选择
weixin_46415189的博客
07-05 513
一、区别 以下源码均来自 jdk 1.8 1、arraylist源码分析 arraylist构造方法 如下： public ArrayList(int initialCapacity) { //指定初始化大小 if (initialCapacity > 0) { this.elementData = new Object[initialCapacity]; } else if (initialCapacity == 0) { this.ele
ArrayList和LinkedList的区别？如何选用？
luxuiary的博客
04-20 463
区别： ArrayList基于数组，LinkedList基于链表; 数组擅长随机查找，链表擅长增加删除;
Java 集合入门：ArrayList 和 LinkedList 怎么选
最新发布
2501_93895174的博客
10-31 295
接口的实现，但底层数据结构和性能特性不同。选择哪个取决于具体应用场景。下面我将逐步解释它们的区别、优缺点，并给出选择建议。本文基于 Java 标准库知识，确保内容真实可靠。在 Java 集合框架中，ArrayList 和 LinkedList 都是。以下 Java 代码展示基本用法，但实际选择应基于上述分析。
ArrayList 和 LinkedList 之间应该怎么选择？
沉默王二
05-11 1550
Joshua Bloch：我写了 LinkedList，但我自己都不用！对，Joshua Bloch 就是 LinkedList 的作者！如果你真信了作者的话，那就真的大错特错了，LinkedList 虽然用的没有 ArrayList 多，但使用它的地方可不少。我在的引用的第三方依赖中，随便搜了一下引用，好多好多地方在用呢，比如说大名鼎鼎的 Jackson。所以，遇到一个问题，比如说：ArrayList 和 LinkedList 之间应该怎么选择？
ArrayList和LinkedList的区别及其选择
NJUSTZJC的博客
10-18 188
ArrayList和LinkedList的区别及其选择
thinkinjava源码-Thinking-in-java:Java编程思想源码及习题！
05-20
这个压缩包文件"Think-in-java-source-Thinking-in-java:Java编程思想源码及习题！"提供了该书第四版中的源码实例，便于读者在IntelliJ IDEA或Eclipse等开发环境中直接使用和学习。 1. **Java编程基础** - **类与...
thinkinjava源码-thinkInJava:java编程思想
05-20
"thinkinjava源码-thinkInJava:java编程思想"这一压缩包文件很可能包含了《Think in Java》一书中部分或全部的示例代码，这些代码可以帮助读者更深入地理解和学习Java。 在这个名为"thinkInJava-master"的压缩包中...
thinkinjava源码-ThinkInJava:java编程思想
05-20
《ThinkInJava:java编程思想》是一本深受程序员喜爱的经典著作，由Bruce Eckel撰写，旨在深入解析Java语言的核心概念和编程技术。源码是学习这本书的重要辅助资源，可以帮助读者更好地理解和实践书中所讲解的内容。...
thinkinjava4源码-Thinking-In-Java4e:java编程思想第4版
05-20
源码包"Thinking-In-Java4e:java编程思想第4版"包含了与书中讲解内容对应的示例代码，是学习和理解Java编程思想的重要资源。 1. **面向对象编程基础**：Java是一种面向对象的编程语言，书中通过实例详细解释了类、...
ArrayList和LinkedList，到底选谁？
HappyDyer的博客
09-01 462
简单来说： ArrayList底层是一个数组，所以查询快； LinkedList底层是一个链表，所以增删快。 区别 线程安全：两者都不是线程安全的。 数据结构：ArrayList 底层是Object数组，LinkedList底层是双向链表。 查询：由于ArrayList是底层是数组，所以可以快速随机访问，通过坐标就可以快速定位，而LinkedList 则不可以。 增删：对于ArrayList 的数组结构来说，如果添加或删除的是第i个数据，那么数组中i之后的所有数据都会向后或向前移动，而链表结构则不会，所以
Java性能调优实战-ArrayList和LinkedList的选用
海恋北斗星
06-18 1016
ArrayList和LinkedList的选用 “ArrayList 和 LinkedList 在新增、删除元素时，LinkedList 的效率要高于 ArrayList，而在遍历的时候，ArrayList 的效率要高于LinkedList。”这个回答是否准确呢？今天这一讲就带你验证。 ArrayList 是如何实现的？ 1.Array...
Java基础面试之集合的选择(ArrayList和LinkedList)
m0_50578062的博客
03-22 158
首先放上一般的结论: ArrayList的底层实现是数组,数组的特点是查询快,增删慢 LinkedList的底层实现是链表, 链表的特点是查询慢增删快 那么问题来了, 这么简单的一个知识点, 怎么让面试官觉得你跟别人不一样. 1.分析下数组为什么查询快, 增删慢? 数组创建时需要一块连续的内存空间, 数组支持随机访问, 所以查询快;增删慢也不是说所有的增删慢,为什么这样说, 要从数组增删的原理来讲(增加的话, 如果是把插入位置及其后面的位置的元素都往后移一位, 然后把要增加的元素放入对应的位置, 删除也是
ArrayList和LinkedList(选择数据结构的衡量标准)
O_ORick的博客
06-19 560
理论是理想,实践实验才是真标准！！以下是理论总结,具体看业务需要和实际生产！ 1. ArrayList 根据元素下标读取快,因此更替元素也快:底层有数组Index. LinkedList根据元素下标读取慢，更替元素慢:底层没有Index. 2.删除:ArrayList删除的元素越靠最前或者靠最后,速度越比同条件的LinkedList快，元素越多越明显。             L
逼着面试官问了我ArrayList和LinkedList的区别，他对我彻底服了
热门推荐
沉默王二
09-28 1万+
ArrayList 在新增和删除元素时，因为涉及到数组复制，所以效率比 LinkedList 低，而在遍历的时候，ArrayList 的效率要高于 LinkedList
Java 编程思想（第4版）学习笔记（LinkedList）
方逸涛的专栏
04-05 680
 jdk1.6帮助文档上LinkedList说明（LinkedList具有直接实现栈的所有功能的方法，因此可以直接将LinkedList作为栈使用。不过，有时一个真正的栈更能把事情讲清楚。）push(v)=addFirst(v)peek(v)=getFirst()pop()=removeFirst()empty()=isEmpty() List 接口的链接列表实现。
如何选择使用ArrayList还是使用LinkList
GuoDa_的博客
06-17 625
ArrayList和LinkList的区别底层实现区别ArrayList和LinkedList遍历的区别 底层实现区别 ArrayList 底层实现就是数组，且ArrayList实现了RandomAccess，表示它能快速随机访问存储的元素，通过下标 index 访问，只是我们需要用 get() 方法的形式， 数组支持随机访问， 查询速度快， 增删元素慢； LinkedList 底层实现是链表， LinkedList 没有实现 RandomAccess 接口，链表支持顺序访问， 查询速度慢， 增删元素快
2020-11-22:在工作中，你会如何选择ArrayList，LinkedList呢？
残冬十九
11-22 268
2020-11-22:在工作中，你会如何选择ArrayList，LinkedList呢？ 前言在工作中，你会如何选择ArrayList，LinkedList呢？ 前言 每日一题专栏 在工作中，你会如何选择ArrayList，LinkedList呢？ ArrayList的底层是数组，所以在内存中的空间是连续的(指的是虚拟的空间)LinkedList的底层是双向链表 在ArrayList的中间插入元素不方便，而在LinkedList的中间插入或者删除元素方便 LinkedList不支持高效的随机元素访问
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

BaymaxCS

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值