Java容器（二）——「ArrayList、LinkedList性能测试与分析」

最新推荐文章于 2022-11-18 22:30:00 发布
最新推荐文章于 2022-11-18 22:30:00 发布
阅读量4.5k 收藏 16
点赞数 13
分类专栏： Java 基础 深入浅出Java容器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luzhenyu111/article/details/79111534
版权

测试目标

集合中最常用的就是List，用于存储可重复的数据集。
为了了解List的几个实现类的性能区别以及使用场景，进行简单的性能测试对比。
我们常规对于ArrayList、LinkedList的认知是：
1. 数据查询的效率（Get的效率）
ArrayList：使用数组，获取数据通过数组下标进行快速定位，性能为O(1)，数据顺序、随机获取的速度快。
LinkedList：使用链表进行数据存储，查询数据需要从头或者从尾部遍历链表，性能O(n)，因此数组数据越多、查询位置越靠中间性能越差。
2. 数据添加的效率（Add的效率）
ArrayList：数组的数据添加，如果在头部或者中间性能最差，因为需要更改后面所有数据的位置和索引。如果在尾部性能则影响不大。
LinkedList：插入的效率比ArrayList和Vector都高，因为只需要更改相应位置前后节点的指向就行。
3. 数据移除的效率（Remove的效率）
数据移除同添加
4. 数据替换的效率（Set的效率）
ArrayList：数据替换由于不需要更改后续数组的位置和索引，因此效率比插入高。同时LinkedList需要定位位置，因此ArrayList也会比LinkedList快。
LinkedList：需要定位替换的位置，效率较低。

根据这些认知，我们可以得到假设：
1. ArrayList
不适宜应用于经常需要在集合中间或者首位进行插入或者删除操作的场景，适宜应用于读取操作多的场景。
2. LinkedList
不适宜应用于随机位置进行读取的场景，适宜于需要在集合中进行插入或者删除的场景。

测试目标：
1. 测试在头、尾进行插入的效率
2. 测试在集合中间随机位置进行随机插入的效率
3. 测试在从集合随机位置获取数据的效率
4. 测试从随机位置替换数据的效率
5. 测试随机位置的数据移除操作

测试代码

ListNature.java

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;

/**
 * @author lzy
 * @date 2018/1/17
 */
public class ListNature extends BaseNature{

    private static Logger logger = LoggerFactory.getLogger(ListNature.class);

    /**
     *
     * @param listSize
     * @param removeCount
     */
    public void testRemoveRandom(int listSize, int removeCount) {
        if (listSize < removeCount) {
            throw new IllegalArgumentException("removeCount需要小于listSize");
        }
        List<String> arrayList = new ArrayList<>();
        List<String> linkedList = new LinkedList<>();
        testAddLast(arrayList, listSize);
        System.gc();
        long arrayRemove = testRemoveRandom(arrayList, removeCount);
        arrayList.clear();
        System.gc();
        testAddLast(linkedList, listSize);
        System.gc();
        long linkedRemove = testRemoveRandom(linkedList, removeCount);
        linkedList.clear();
        System.gc();

        logger.debug("于{}集合数据量下，{}次测试Array与LinkedList测试随机删除，结果如下：===",listSize,removeCount);
        logger.debug("ArrayList：耗时{}",arrayRemove);
        logger.debug("LinkedList：耗时{}",linkedRemove);

    }

    /**
     *
     * @param listSize
     * @param replaceCount
     */
    public void testReplaceRandom(int listSize, int replaceCount) {
        List<String> arrayList = new ArrayList<>();
        List<String> linkedList = new LinkedList<>();
        testAddLast(arrayList, listSize);
        long arrayReplace = testReplaceRandom(arrayList, replaceCount);
        arrayList.clear();
        System.gc();
        testAddLast(linkedList, listSize);
        long linkedReplace = testReplaceRandom(linkedList, replaceCount);
        linkedList.clear();
        System.gc();

        logger.debug("于{}集合数据量下，{}次测试Array与LinkedList测试随机替换，结果如下：===",listSize,replaceCount);
        logger.debug("ArrayList：耗时{}",arrayReplace);
        logger.debug("LinkedList：耗时{}",linkedReplace);
    }

    /**
     * 测试ArrayList和LinkedList集合随机获取数据的效率
     *
     * @param listSize 集合原始容量
     * @param getCount 获取次数
     */
    public void testGetRandom(int listSize, int getCount) {
        List<String> arrayList = new ArrayList<>();
        List<String> linkedList = new LinkedList<>();
        testAddLast(arrayList, listSize);
        long arrayGet= testGetRandom(arrayList, getCount);
        arrayList.clear();
        System.gc();
        testAddLast(linkedList, listSize);
        long linkedGet = testGetRandom(linkedList, getCount);
        linkedList.clear();
        System.gc();

        logger.debug("于{}集合数据量下，{}次测试Array与LinkedList测试随机获取，结果如下：===",listSize,getCount);
        logger.debug("ArrayList：耗时{}",arrayGet);
        logger.debug("LinkedList：耗时{}",linkedGet);
    }

    /**
     * 测试ArrayList和LinkedList集合中随机插入数据的效率
     *
     * @param listSize    数组原始容量
     * @param insertCount 插入次数
     */
    public void testInsertRandom(int listSize, int insertCount) {
        List<String> arrayList = new ArrayList<>();
        List<String> linkedList = new LinkedList<>();
        testAddLast(arrayList, listSize);
        long arrayInsert = testInsertRandom(arrayList, insertCount);
        arrayList.clear();
        System.gc();
        testAddLast(linkedList, listSize);
        long linkedInsert = testInsertRandom(linkedList, insertCount);
        linkedList.clear();
        System.gc();

        logger.debug("于{}集合数据量下，{}次测试Array与LinkedList测试随机添加，结果如下：===",listSize,insertCount);
        logger.debug("ArrayList：耗时{}",arrayInsert);
        logger.debug("LinkedList：耗时{}",linkedInsert);
    }

    /**
     * 测试ArrayList和LinkedList集合中首尾插入数据的效率
     *
     * @param addCount 插入次数
     */
    public void testAddFirstAndLast(int addCount) {
        List<String> arrayList = new ArrayList<>();
        List<String> linkedList = new LinkedList<>();
        long arrayListAddFirst =  testAddFirst(arrayList, addCount);
        System.gc();
        long arrayListAddLast = testAddLast(arrayList, addCount);
        arrayList.clear();
        System.gc();
        long linkedListAddFirst = testAddFirst(linkedList, addCount);
        System.gc();
        long linkedListAddLast = testAddLast(linkedList, addCount);
        linkedList.clear();
        System.gc();

        logger.debug("{}次测试Array与LinkedList测试头尾添加，结果如下：===",addCount);
        logger.debug("ArrayList：头部添加耗时{},尾部添加耗时{}",arrayListAddFirst,arrayListAddLast);
        logger.debug("LinkedList：头部添加耗时{},尾部添加耗时{}",linkedListAddFirst,linkedListAddLast);
    }

    private long testAddFirst(List list, int addCount) {
        int[] array = getRandomArray(addCount);
        long time1 = System.currentTimeMillis();
        for (int i = 0; i < addCount; i++) {
            list.add(0, array[i]);
        }
        long time2 = System.currentTimeMillis();
        long interval = time2 - time1;
        return interval;
    }

    private long testAddLast(List list, int addCount) {
        int[] array = getRandomArray(addCount);
        long time1 = System.currentTimeMillis();
        for (int i = 0; i < addCount; i++) {
            list.add(array[i]);
        }
        long time2 = System.currentTimeMillis();
        long interval = time2 - time1;
        return interval;
    }

    private long testInsertRandom(List list, int insertCount) {
        int[] array = getRandomArray(insertCount, list.size());
        long time1 = System.currentTimeMillis();
        for (int i = 0; i < insertCount; i++) {
            list.add(array[i], array[i]);
        }
        long time2 = System.currentTimeMillis();
        long interval = time2 - time1;
        return interval;
    }

    private long testReplaceRandom(List list, int replaceCount) {
        int[] array = getRandomArray(replaceCount, list.size());
        long time1 = System.currentTimeMillis();
        for (int i = 0; i < replaceCount; i++) {
            list.set(array[i], array[i]);
        }
        long time2 = System.currentTimeMillis();
        long interval = time2 - time1;
        return interval;
    }

    private long testGetRandom(List list, int getCount) {
        int[] array = getRandomArray(getCount, list.size());
        long time1 = System.currentTimeMillis();
        for (int i = 0; i < getCount; i++) {
            list.get(array[i]);
        }
        long time2 = System.currentTimeMillis();
        long interval = time2 - time1;
        return interval;
    }

    private long testRemoveRandom(List list, int removeCount) {
        int[] array = getRandomArray(removeCount, list.size() / 100);
        long time1 = System.currentTimeMillis();
        for (int i = 0; i < removeCount; i++) {
            list.remove(array[i]);
        }
        long time2 = System.currentTimeMillis();
        long interval = time2 - time1;
        return interval;
    }
}

ListNatureTest.java

import org.junit.Test;

/**
 * @author lzy
 * @date 2018/1/18
 */
public class ListNatureTest {

    @Test
    public void testAdd() {
        int[] testCount = {10000, 50000,100000};
        ListNature natureTest = new ListNature();
        for (int i : testCount) {
            natureTest.testAddFirstAndLast(i);
        }
    }

    @Test
    public void testInsert() {
        int[] testCount = {10000, 50000,100000};
        int[] listSize = {10000, 50000,100000};
        ListNature natureTest = new ListNature();
        for (int i : testCount) {
            for (int j : listSize) {
                natureTest.testInsertRandom(j, i);
            }
        }
    }

    @Test
    public void testGet() {
        int[] testCount = {10000, 50000,100000};
        int[] listSize = {10000, 50000,100000};
        ListNature natureTest = new ListNature();
        for (int i : testCount) {
            for (int j : listSize) {
                natureTest.testGetRandom(j, i);
            }
        }
    }

    @Test
    public void testReplace() {
        int[] testCount = {10000, 50000,100000};
        int[] listSize = {10000, 50000,100000};
        ListNature natureTest = new ListNature();
        for (int i : testCount) {
            for (int j : listSize) {
                natureTest.testReplaceRandom(j, i);
            }
        }
    }

    @Test
    public void testRemove() {
        int[] testCount = {10000, 50000};
        int[] listSize = {100000,200000};
        ListNature natureTest = new ListNature();
        for (int i : testCount) {
            for (int j : listSize) {
                natureTest.testRemoveRandom(j, i);
            }
        }
    }

}

测试结果

测试的结果影响因素很多，但是我们主要是定性测试，因此不要纠结于具体的时间毫秒数，而是要了解每个组件的性能趋势。

1.查询测试

数据的查询考虑的是查询次数以及数组长度两个维度，因此各自使用1w、5w、10w三种测试场景，单位毫秒(ms)。

A：ArrayList
L：LinkedList

测试次数A(1w)L(1w)A(5w)L(5w)A (10w)L(10w)
1w199155211156
5w12851164916133
10w1107914773111421

2.添加测试

A首：ArrayList首位添加
L首：LinkedList首位添加
A尾：ArrayList的尾部添加
L尾：LinkedList的尾部添加
结果1：

测试次数A首(ms)L首(ms)A尾(ms)L尾(ms)
1w次15412
5w次210642
10w次899281

测试在数组中随机插入，主要需要考虑数组的原本的长度，因此取三个较大的数组长度的放大两者之间的差距1w、10w、100w
A中：在N条数据内的随机插入，ArrayList的中间随机插入
L中：LinkedList的中间随机插入
结果2：

测试次数A中(1w)L中(1w)A中(5w)L中(5w)A中 (10w)L中(10w)
1w次19480511734921685
5w次22245233071374068721928
10w次9359287167649533264882517

3.删除测试
原计划是分队列头部、尾部、随机位置三个场景测试，考虑到头部删除、尾部删除于头尾插入类似，因此只需要测试随机位置删除即可。测试需要考虑数组的原本的长度以及删除的数据数量，即删除数量需要大于数组原本长度。因此测试数据量为10w、100w

测试次数A(10w)L(10w)A (20w)L(20w)
1w次1051721634
5w次34979949211

4.替换测试
直接上替换测试结果：

测试次数A(1w)L(1w)A(5w)L(5w)A (10w)L(10w)
1w次38113081742
5w次23371216014792
10w次183144818110023

测试结果分析

从测试结果反应的时间来看，可以得到以下几点结论：

  1. ArrayList无论在多大的数据量的情况下，获取元素的效率都相差不大。随机获取的效率总体上比LinkedList高
  2. LinkedList和ArrayList在尾部添加数据的效率相差不大，头部添加则LinkedList明显优于ArrayList
  3. ArrayList元素随机替换效率和查询效率相同，都比较高。LinkedList效率较低。
  4. 随机插入的效率ArrayList反而比LinkedList高。

源码分析

1. Get对比
ArrayList的get非常简单，伴随着一个数组范围检查后直接是范围相应位置的元素，非常的简单高效。



public E get(int index) {
    //判断 index<size,否则抛出IndexOutOfBoundsException
    rangeCheck(index);
    return elementData(index);
}

LinkedList的get通过链表的头或者尾进行遍历，直到找到index位置的对象。

public E get(int index) {
    //判断index>=0&&index<size，否则抛出IndexOutOfBoundsException
    checkElementIndex(index);
    return node(index).item;
}

Node<E> node(int index) {
    // assert isElementIndex(index);

    if (index < (size >> 1)) {
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

从两者的Get实现角度看，集合中元素的数量对于ArrayList的获取性能影响不大，性能比较稳定。而LinkedList的效率则关乎获取元素的位置，离集合的头或尾越近，性能越好，反之则越差。

2.Add对比
ArrayList 在顺序插入时,如果数据容量不够,会经常扩容,其中扩容代码Arrays.copyOf(elementData, newCapacity); 会消耗大量时间,但如果数据量较大,此时扩容次数明显下降(扩容总是会在当前容量的1.5倍),因此扩容消耗的时间平均下来明显降低。

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
//扩容判断
private void ensureExplicitCapacity(int minCapacity) {
    //用于Fail-Fast判断
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}
// 新的数组长度为原数组的长度*1.5，若是小于最小长度则赋值为最小长度。若大于最大长度（Integer.MAX_VALUE-8），则赋值为Integer.MAX_VALUE
private void grow(int minCapacity) {
   // overflow-conscious code
   int oldCapacity = elementData.length;
   int newCapacity = oldCapacity + (oldCapacity >> 1);
   if (newCapacity - minCapacity < 0)
       newCapacity = minCapacity;
   if (newCapacity - MAX_ARRAY_SIZE > 0)
       newCapacity = hugeCapacity(minCapacity);
   // minCapacity is usually close to size, so this is a win:
   elementData = Arrays.copyOf(elementData, newCapacity);
}

LinkedList 顺序插入，先新增一个前节点，绑定前一节点为last，最后把新增节点置为last。

public boolean add(E e) {
    linkLast(e);
    return true;
}
void linkLast(E e) {
    final Node<E> l = last;
    final Node<E> newNode = new Node<>(l, e, null);
    last = newNode;
    if (l == null)
        first = newNode;
    else
        l.next = newNode;
    size++;
    modCount++;
}

3. add(int index, E element)中间插入对比
ArrayList需要进行数组拷贝，把index位置之后的元素整体后移一位，如果数组较长且index位置靠前（即index之后元素较多），会浪费大量时间,因此插入时间会呈指数级增长。

public void add(int index, E element) {
    rangeCheckForAdd(index);

    ensureCapacityInternal(size + 1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    elementData[index] = element;
    size++;
}

LinkedList的数据插入，主要消耗在index位置的链表定位上，index位置的查找速度越快，则插入速度越快。

public void add(int index, E element) {
    checkPositionIndex(index);

    if (index == size)
        linkLast(element);
    else
        linkBefore(element, node(index));
}

remove也是同理，ArrayList主要是拷贝，LinkedList主要是定位。
set对于ArrayList同get，而LinkedList主要是定位。

综合以上各项数据,对于两个集合使用有以下建议：
1、大部分的情况下使用ArrayList即可
2、在数组长度能够确定的情况下，使用ArrayList更优，避免了数组扩容
3、频繁添加删除(在 list 开始部分)，但不需要频繁访问，可以考虑使用LinkedList
4、分不清场景下需要使用哪一种的，建议结合着业务做一下测试。

疯狂的bug
关注
  • 13
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
Java源码篇之容器类——ArrayList
12-20
Java源码篇之容器类——ArrayList1、前言2、ArrayList的类关系3、ArrayList的源码一、类的属性二、add()方法三、get()方法四、remove()方法五、set()方法4、总结 1、前言 对于平常开发的时候遇到的ArrayList，在此做一个简单的源码阅读记录，JDK1.8版本。 2、ArrayList的类关系 原创文章 13获赞 15访问量 7万+ 关注
ArrayList 与 LinkedList 的添加、查询效率测试
qq_45235575的博客
01-25 1034
单列集合ArrayList 与 LinkedList ArrayList 数组集合 查询快 增删中间元素效率低 LinkedList 链表集合 查询慢 增删快 下面编写了一个程序来测试ArrayList与LinkedList插入、查询的时间效率，如下所示： import java.util.ArrayList; import java.util.LinkedList; /** * @author bzc * @date 2022/1/25 * @apiNote Ar...
深入理解ArrayList与LinkedList，源码分析与性能测试
她的坏机器人
08-01 220
剧透：ArrayList的插入操作与查询操作都比LinkedList快很多 ArrayList 特点 底层使用数组实现，查询速度快，增删改速度慢（理论上） 线程不安全 ArrayList常用方法 import java.util.ArrayList; import java.util.Iterator; import java.util.List; /** * @author 张宝旭 */ public class ArrayListTest { public static voi..
（java）测试ArrayList和LinkedList存,查效率
weixin_56587881的博客
07-10 142
集合习题
8、集合--LinkedList的测试以及相关方法的源码分析
weixin_33918357的博客
05-10 105
LinkedList测试 public static void main(String[] args) { List list = new LinkedList(); //添加元素 list.add(1); list.add(2); //在指定位置添加元素 lis...
ArrayList与LinkedList的性能分析
许洪昌的博客
06-03 3102
1、 前言 经常在面试时，被问到集合的概念，集合 List、Map、Set 等底层设计以及其使用场景与注意细节。但大部分人的回答都是千篇一律，跟网上的答案一模一样，这是致命滴。其实，大家都错了，尤其是网上，更是误导大家，详细原因，且听我来分析。 2、集合 List 2.1 大家心中的 List 在广大的网友心中，List 是一个缓存数据的容器，是 JDK 为开发者提供的一种集合类型。面试时，被问到最常见的就是 ArrayList 和 LinkedList 的区别。 相信大部分...
Java基础(一)-ArrayList和LinkedList性能对比与原因探索
weixin_44212764的博客
03-18 884
今天学习的时候，看到一篇文章，说LinkedList的作者自己不用LinkedList，感觉十分的吃惊。 本着实践出真知的态度，立刻写了几行代码用于测试ArrayList和LinkedList的在增删查改四大方面的性能对比(测试所有代码放在文末)。经过一番测试后，我得到了如下的对比图（由于随即插入，查找，删除，修改等操作LinkedList的时间简直慢得令人发指，因此只测试了在大量数据情况下对少量数据的更改操作）： 有意思的是，在我们学习数组和链表上，经常有如下结论： 数组随机访问快，但随即插入删除
ArrayList与LinkedList性能分析
AG.『Feng』的博客
11-18 1209
浅谈ArrayList和LinkedList性能
LinkedList 真的是查找慢增删快？
weixin_44421461的博客
10-02 536
点击上方“Java基基”，选择“设为星标”做积极的人，而不是积极废人！源码精品专栏原创 | Java 2020超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析...
Java中ArrayList和LinkedList的遍历与性能分析
09-01
主要给大家介绍了ArrayList和LinkedList这两种list的五种循环遍历方式，各种方式的性能测试对比，根据ArrayList和LinkedList的源码实现分析性能结果，总结结论。相信对大家的理解和学习具有一定的参考价值，有需要的...
ArrayList LinkedList Vector性能测试
05-03
比较ArrayList,LinkedList,Vector三者随机读取，插入，删除性能。
java 中ArrayList与LinkedList性能比较
08-31
主要介绍了java 中ArrayList与LinkedList性能比较的相关资料,需要的朋友可以参考下
JAVA LinkedList和ArrayList的使用及性能分析
09-04
JAVA LinkedList和ArrayList的使用及性能分析，这篇文章也是以JAVA List的总结。
Java小细节——switch有无break的区别
疯狂的Bug
02-14 2868
阅读2分钟，掌握一个Java小细节，你值得拥有！ switch大家都很熟悉，可以从一系列代码中选出一段去执行，它的格式如下： switch(c){ case 1:statement；break; case 2:statement；break; case 3:statement；break; case 4:statement；break; ca...
Java容器—— 「通过数组实现自己的ArrayMap」
疯狂的Bug
01-25 1475
前言 在Java编程语言中，最基本的结构就是两种，一种是数组，一种是模拟指针(引用),所有的数据结构都可以用这两个基本结构构造。 本文主题就是通过数组的方式实现Map的key-value存储(以下称为ArrayMap)，然后在后续章节通过ArrayMap与Java自带的HashMap进行对比，来直观的了解Hash算法相对比数组存储性能的优势。 实现思路 ArrayMap的主要功能在Ma
Java 小细节——方法基本类型参数的重载
疯狂的Bug
02-17 790
阅读2分钟，掌握一个Java小细节，你值得拥有！ 方法重载指的是方法名相同，参数列表不同（不同的参数类型或者参数顺序或者参数个数）的情况。不过你真的了解么？看看下面这个例子。 public class PrimitiveOverloading { void f1(char x){ System.out.println("f1(char)"); } ...
Java小细节——try/catch/finally/return不得不说的秘密
疯狂的Bug
02-17 415
阅读2分钟，掌握一个Java小细节，你值得拥有！ java面试经常能看到这道题目： try {} 里有一个return语句，那么紧跟在这个try后的finally {}里的代码会不会被执行?什么时候被执行?在return前还是后? try/catch/finally 都有return 语句 public class tryCatchDemo { public ...
Java容器—— 「实现自己的HashMap」
疯狂的Bug
01-27 381
一、前言 上一篇文章实现了自己的ArrayMap，但是对于Key-Value使用单纯数组进行存储，那么性能实在是惨不忍睹。此种情况下哈希表的数据结构是比较合适的解决方案。 哈希表就是一种以 键-值(key-indexed) 存储数据的结构，我们只要输入待查找的值即key，即可查找到其对应的值。 哈希的思路很简单，如果所有的键都是整数，那么就可以使用一个简单的无序数组来实现：将键作为
单元测试——ArrayList
最新发布
10-12
单元测试是一种软件测试方法，用于测试程序中的最小可测试单元——函数、方法或类。在引用中，我们展示了如何使用JUnit进行单元测试，以及如何使用ArrayList和自定义类进行测试。在测试中，我们可以使用断言来验证代码的正确性。在测试ArrayList时，我们可以使用for循环遍历列表并使用get方法获取元素。在测试自定义类时，我们可以使用equals方法来比较对象是否相等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值