ArrayList集合简单源码分析+一道面试题

最新推荐文章于 2024-06-19 15:09:37 发布
最新推荐文章于 2024-06-19 15:09:37 发布
阅读量408 收藏 9
点赞数 10
文章标签： java 面试 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61925586/article/details/135889610
版权

ArrayList类中的属性

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    @java.io.Serial
    private static final long serialVersionUID = 8683452581122892189L;

    /**
     * DEFAULT_CAPACITY表示集合默认的初始容量
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 空数组EMPTY_ELEMENTDATA，在使用有参构造方法时传递0进去，创建ArrayList集合时就会使用这个数组
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
        默认容量的空数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA
    */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * 集合中真实存储元素的数组elementData
     */
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     * 集合中元素的个数
     * @serial
     */
    private int size;    //int类型的成员变量初始值为0

ArrayList类中的构造方法

  • 无参构造方法：相当于内部创建了一个空的数组

    /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
        //将成员变量中的 默认容量的空数组 赋值给 真实存储元素的数组
        //this.elementData = {}
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

  • 有参构造方法分析：内部创建了一个指定长度的数组 并赋值给了elementData

main方法：

   
public class Test {
    public static void main(String[] args) {
        ArrayList list = new ArrayList(20);  //创建一个指定初始容量为20的ArrayList集合
    }
}

  • 有参构造方法源码：

    public ArrayList(int initialCapacity) {   // initialCapacity=20
        if (initialCapacity > 0) {
            //内部创建了一个长度为20的数组，并赋值给this.elementData
            this.elementData = new Object[initialCapacity]; 
        } else if (initialCapacity == 0) {
            //如果传递的是0，就将空数组EMPTY_ELEMENTDATA 赋值给 this.elementData
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            //如果在构造方法中传递负数，就会抛出如下异常
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

无参构造方法创建的对象：添加方法

第一次添加数据：

在main方法中：

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList list1 = new ArrayList();
        list1.add(1);   //添加第一个元素进去
    }
}

第一次添加数据的流程：

  • 一级一级的调用下去

    public boolean add(E e) {
        //确定内部数组的容量          0 + 1
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //将要添加的元素 添加 到数组中有数据的下一个位置
        elementData[size++] = e;        
        return true;
    }

-------------------------------------------------------------------------------------
    //minCapacity:是ArrayList集合需要的最小容量（暂时这样理解）
    private void ensureCapacityInternal(int minCapacity) { // minCapacity=1
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {   // {}=={}
            // 						10					1
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
 
        //通过得到的minCapacity去确定数组的长度
        ensureExplicitCapacity(minCapacity);
    }

-------------------------------------------------------------------------------------
    private void ensureExplicitCapacity(int minCapacity) {  //minCapacity=10
        modCount++;   //记录对当前集合操作的次数
 
        // 集合需要的最小容量minCapacity 大于 elementData数组的长度时就会扩容(也就是当集合内部的数组不够存储元素时才会扩容)    10-0
        if (minCapacity - elementData.length > 0)
            //扩容
            grow(minCapacity);
    }

-------------------------------------------------------------------------------------
	private void grow(int minCapacity) {    //minCapacity=10
		int oldCapacity = this.elementData.length;   //原来的数组长度为0
		int newCapacity = oldCapacity + (oldCapacity >> 1);    //新的容量0
        
		if (newCapacity - minCapacity < 0) {   //0 - 10 < 0，执行
			newCapacity = minCapacity;     //newCapacity = 10 
		}
 
		if (newCapacity - 2147483639 > 0) {  //10 - 21亿 < 0
			newCapacity = hugeCapacity(minCapacity);
		}
 
        //将空数组{} 复制到 一个长度为 10的新数组中，然后将新的数组赋值给elementData。此时size还是0
		this.elementData = Arrays.copyOf(this.elementData, newCapacity);
	}

	//然后回去继续向下执行，执行的就是向数组中添加数据的操作
    public boolean add(E e) {
        //确定内部数组的容量        0 + 1
        ensureCapacityInternal(size + 1);  // 0 + 1
        //将要添加的元素 添加 到数组中有数据的下一个位置
        elementData[size++] = e;        //elementData={e，，，，，，，，，} 数组的length=10，size=1
        return true;
    }
第二次添加元素：

  • 第二次添加元素也还不会扩容

main方法中：

package string.demo;

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList list1 = new ArrayList();
        list1.add(1);
        list1.add(2);  //第二次添加数据
    }
}

第二次添加元素的执行流程：

    public boolean add(E e) {
        //确定内部数组的容量 1 + 1 = 2
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //将要添加的元素 添加 到数组中有数据的下一个位置
        elementData[size++] = e;        
        return true;
    }

-------------------------------------------------------------------------------------
    private void ensureCapacityInternal(int minCapacity) { // minCapacity=2
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {   // {1，，，...}！={} 不执行语句体
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
 
        //确定数组的容量
        ensureExplicitCapacity(minCapacity);
    }

-------------------------------------------------------------------------------------
    private void ensureExplicitCapacity(int minCapacity) {  minCapacity=2
        modCount++;   //记录对当前集合操作的次数 modCount=modCount + 1   (modCount=2)
 
        // 集合需要的最小容量minCapacity 大于 elementData数组的长度时就会扩容    2 - 10 < 0:不执行if语句体，也就是不扩容
        if (minCapacity - elementData.length > 0)
            //扩容
            grow(minCapacity);
    }
-----------------------------------------------------------------------------------------
    //然后回去继续向下执行，执行的就是向数组中添加数据的操作
    public boolean add(E e) {
        //确定内部的容量 0 + 1
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //将要添加的元素 添加 到数组中有数据的下一个位置
        elementData[size++] = e;     //  {1，2，.....}  此时：数组length = 10，元素个size=2
        return true;
    }
第十一次添加元素

  • 此时ArrayList集合内部的数组不够存储新元素了，会扩容

    public boolean add(E e) {
        //此时elementData数组：{1,2,3,4,5,6,7,8,9,10}   size = 10 , length = 10
        ensureCapacityInternal(size + 1);  // 10 + 1 =11
        //将要添加的元素 添加 到数组中有数据的下一个位置
        elementData[size++] = e;    
        return true;
    }

-------------------------------------------------------------------------------------
    private void ensureCapacityInternal(int minCapacity) {  minCapacity = 11
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {   
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
 
        //确定数组的容量
        ensureExplicitCapacity(minCapacity);  //11
    }

-------------------------------------------------------------------------------------
    private void ensureExplicitCapacity(int minCapacity) {  minCapacity=11
        modCount++;   //记录对当前集合操作的次数 modCount=modCount + 1   (modCount=11)
 
        // minCapacity 大于 elementData数组的长度时就会扩容    11-10 > 0:扩容
        if (minCapacity - elementData.length > 0)
            //扩容
            grow(minCapacity);
    }

-------------------------------------------------------------------------------------
	private void grow(int minCapacity) {    //minCapacity=11
    	//oldCapacity = 10
		int oldCapacity = this.elementData.length;  //获取原容量的长度
    
    	//新的容量newCapacity是在原容量的基础上扩容1.5倍
    	//newCapacity = 10 + 5
		int newCapacity = oldCapacity + (oldCapacity >> 1);    
        
		if (newCapacity - minCapacity < 0) {   //15 - 11 > 0,不执行
			newCapacity = minCapacity;     
		}
 
		if (newCapacity - 2147483639 > 0) {  //15 - 21亿 < 0，不执行
			newCapacity = hugeCapacity(minCapacity);
		}
 
        //将{1,2,3,4,5,6,7,8,9,10}长度为10的数组 复制到 长度为 15的新数组中，然后将新的数组赋值给elementData。
		this.elementData = Arrays.copyOf(this.elementData, newCapacity);
	}

	//再回去执行向数组中添加元素的逻辑
    public boolean add(E e) {
        //此时elementData数组：{1,2,3,4,5,6,7,8,9,10}   size = 10 , length = 10
        ensureCapacityInternal(size + 1);  // 10 + 1 =11
        //将要添加的元素 添加 到数组中有数据的下一个位置{1,2,3,4,5,6,7,8,9,10,11,,,,} 此时size=11 length=15
        
        elementData[size++] = e;    
        return true;
    }

有参构造方法创建的对象：添加方法

执行时调用的方法都和无参的一样

main方法：

package string.demo;

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        //elementData = {,,,,,} 长度为20的数组
        ArrayList list2 = new ArrayList(20);
        list2.add(1);
    }
}

添加数据：

    public boolean add(E e) {
        //确定内部的容量 0 + 1
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //将要添加的元素 添加 到数组中有数据的下一个位置
        elementData[size++] = e;        
        return true;
    }

-------------------------------------------------------------------------------------
    
    private void ensureCapacityInternal(int minCapacity) { // minCapacity=1
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {   // elementData != {}不执行
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
 
        //确定数组的容量
        ensureExplicitCapacity(minCapacity);
    }

-------------------------------------------------------------------------------------
    private void ensureExplicitCapacity(int minCapacity) {  //minCapacity=1
        modCount++;   //记录对当前集合操作的次数
 
        // 集合中的元素个数 等于数组的长度时才会扩容   
        if (minCapacity - elementData.length > 0)  //1 - 20 < 0 不扩容
            //扩容
            grow(minCapacity);
    }

-------------------------------------------------------------------------------------
	private void grow(int minCapacity) {      
		int oldCapacity = this.elementData.length;   
		int newCapacity = oldCapacity + (oldCapacity >> 1);    //新的容量
        
		if (newCapacity - minCapacity < 0) {   
			newCapacity = minCapacity;     
		}
 
		if (newCapacity - 2147483639 > 0) {  
			newCapacity = hugeCapacity(minCapacity);
		}
 
		this.elementData = Arrays.copyOf(this.elementData, newCapacity);
	}

ArrayList中的get方法

main方法：

package string.demo;

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList list1 = new ArrayList();
        list1.add(1);
        list1.add(2);
        list1.get(0);
    }
}

ArrayList中的get方法源码：

    public E get(int index) {
        //检查下标是否合法
        Objects.checkIndex(index, size);
        //通过下标获取数组中对应的元素
        return elementData(index);
    }

ArrayList中的set方法

main方法：

package string.demo;

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList list1 = new ArrayList();
        list1.add(1);
        list1.add(2);
        list1.set(1,"aaa");
    }
}

ArrayList中的set方法源码：

jdk17：

    public E set(int index, E element) {
        Objects.checkIndex(index, size); //检查下标是否合法
        E oldValue = elementData(index);  //获取原来下标对应的元素
        elementData[index] = element;   //将新的元素赋值给数组中对应的下标位置上
        return oldValue;   //返回原来的值
    }

过去版本的jdk：

    public E set(int index, E element) {
        rangeCheck(index);  //检查下标是否合法
 
        E oldValue = elementData(index);  //获取原来下标对应的元素
        elementData[index] = element;   //将新的元素赋值给数组中对应的下标位置上
        return oldValue;   //返回原来的值
    }

ArrayList中的remove方法：

main方法：

package string.demo;

import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {
        ArrayList list1 = new ArrayList();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        list1.add(4);
        list1.add(5);
        list1.add(6);
        list1.add(7);
        list1.add(8);
        list1.add(9);
        list1.remove(3);
    }
}

ArrayList中的remove方法源码：

过去版本的jdk:

    public E remove(int index) {     index=3
        rangeCheck(index);    //检查下标
 
        modCount++;  //记录修改当前集合的次数
        E oldValue = elementData(index);  //获取原来下标上的元素
 
        //计算要移动的元素的个数{1,2,3,4,5,6,7,8,9} 
                             //{1,2,3,5,6,7,8,9,null}
        int numMoved = size - index - 1;    //9 - 3 - 1 = 5
        if (numMoved > 0)
            System.arraycopy(elementData   //原数组
                             , index+1   //开始移动的下标 5,6,7,8,9
                             , elementData   //目标数组
                             , index,   //开始的下标
                             numMoved   //要移动的元素个数
                            );
                                
        //{1,2,3,5,6,7,8,9，null}                        
        elementData[--size] = null; // clear to let GC do its work
 
        return oldValue;
    }
    public E remove(int index) {
        Objects.checkIndex(index, size);
        final Object[] es = elementData;

        @SuppressWarnings("unchecked") E oldValue = (E) es[index];
        fastRemove(es, index);

        return oldValue;
    }

TreeSet的实现原理

在构造方法中创建了一个TreeMap实例

    public TreeSet() {
        this(new TreeMap<>());
    }

在调用add方法时，本质上是调用了TreeMap的put方法

    public boolean add(E e) {
        return m.put(e, PRESENT)==null;
    }

Hashset的实现原理

在其无参构造方法中实例化了一个HashMap实例

    public HashSet() {
        map = new HashMap<>();
    }

在调用add方法的时候本质上是调用了HashMap的put方法

    public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

去除ArrayList集合中重复的元素

方式一：

会创建一个新的ArrayList集合

package collection;

import java.util.ArrayList;

public class ListTest {
    public static void main(String[] args) {
        ArrayList list1 = new ArrayList();
        list1.add(1);
        list1.add(3);
        list1.add(2);
        list1.add(null);
        list1.add("张三");
        list1.add("李四");
        list1.add(3);
        System.out.println(list1);
        //新创建一个List集合存储去重后的元素
        ArrayList list2 = new ArrayList();
        for (Object o : list1){   //遍历原来的集合
            if (!list2.contains(o)){   //判断新的集合中是否包含list1中的元素，如果没有则1添加到list2中
                list2.add(o);
            }
        }
        System.out.println(list2);

    }
}

运行结果：

[1, 3, 2, null, 张三, 李四, 3]

[1, 3, 2, null, 张三, 李四]

方式二

不创建新集合，使用选择排序的思想去除重复元素

package collection;

import java.util.ArrayList;

public class ListTest {
    public static void main(String[] args) {
        ArrayList list1 = new ArrayList();
        list1.add(1);
        list1.add(3);
        list1.add(2);
        list1.add(2);
        list1.add(2);
        list1.add("张三");
        list1.add("李四");
        list1.add(3);
        System.out.println(list1);

        for (int i = 0;i < list1.size() - 1;i++){
            for (int j = i + 1;j<list1.size();j++){
                if (list1.get(i).equals(list1.get(j))){
                    list1.remove(j);
                    j--;
                }
            }
        }
        System.out.println(list1);
    }
}

雪球不会消失了
关注
  • 10
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【源码那些事】超详细的ArrayList底层源码+经典面试题
wenwenaier的博客
12-12 3530
【jdk源码】爆肝！超详细的ArrayList底层源码，你值得拥有
java之List集合----ArrayList、LinkedList、Vector详解（底层源码分析+常见面试题）
weixin_51201930的博客
01-13 492
文章目录前言一、Collection接口二、List集合1. ArrayList类1.1 ArrayList存储方式1.2 三种遍历List集合的方式1.3 ArrayList扩容机制2. LinkedList类2.1 LinkedList存储方式2.2 LinkedList查询机制3. Vector面试案例1：遍历一个List有哪些不同的方式？面试案例2：三种遍历方式如何选取呢？面试案例3：说说ArrayList 的扩容机制？面试案例4：Array和ArrayList有何区别？什么时候更适合使用Array
ArrayList和SubList的坑面试题
web15085181368的博客
06-01 73
不要，思考一下会打印出什么？ 执行结果： 你是否感觉疑惑？在想为什么在list2添加的在list1也添加是吧？subList接口 我们使用的是ArrayList，所以是选择ArrayList即可 fromIndex是从List元素开始索引，toIndex是List元素结束索引，subListRangeCheck方法是检查是否在允许范围之内。 重头戏在new SubList(this, 0, fromIndex, toIndex);这里，看看下面的SubList就会知道，this关键字将当
ArrayList相关面试题
wangjun1018的博客
01-03 551
ArrayList的插入或删除一定慢吗? 取决于插入或删除的元素距离有多远,如果不是最后一个元素,则在插入或者删除时,需要移动该位置往后的元素, 在插入时且在数组的末端,如果底层数组的容量已经小于当前list容量,则根据ArrayList的扩容机制需要增大1.5倍的容量,并初始化一个新的数组,将原有的数据复制到新的数组中去,比较耗费资源,如果不是末端,还需要移动该位置之后的元素。 所...
鹅厂面试题、大厂面试题、JVM面试题
02-07
在这篇文章中，我们将讨论鹅厂面试题、大厂面试题、JVM面试题，并对每个问题进行详细的解释和分析。 首先，让我们来讨论 TCP 和 UDP 的区别。TCP 是一个全双工协议，这意味着它可以同时发送和接收数据，而 UDP 则是...
最新Java面试题视频网盘，Java面试题84集、java面试专属及面试必问课程
06-24
│ Java面试题10.ArrayList LinkedList.mp4 │ Java面试题11.HashMap和HashTable的区别.mp4 │ Java面试题12.实现一个拷贝文件的类使用字节流还是字符串.mp4 │ Java面试题13.线程的实现方式 怎么启动线程怎么区分...
「Java学习+面试指南」一份涵盖大部分 Java 程序员所需要掌握的核心知识 准备 Java 面试，首选.zip
04-15
源码分析 ： ArrayList 源码+扩容机制分析 HashMap(JDK1.8)源码+底层数据结构分析 ConcurrentHashMap 源码+底层数据结构分析 IO IO 基础知识总结 IO 设计模式总结 IO 模型详解 并发 知识点/面试题总结 : (必看 ) ...
「Java学习+面试指南」一份涵盖大部分 Java 程序员所需要掌握的核心知识
05-21
源码分析： ArrayList 源码+扩容机制分析 HashMap(JDK1.8)源码+底层数据结构分析 ConcurrentHashMap 源码+底层数据结构分析 IO IO 基础知识总结 IO 设计模式总结 IO 模型详解 并发 知识点/面试题总结 : (必看 ) ...
java面试笔试资料包括JAVA基础核心知识点深度学习Spring面试题等资料合集.zip
08-20
Spring源码分析之IoC.docx 关于线程和线程池的学习与使用.docx 深入理解JVM垃圾回收机制.docx 深入理解多线程实现的另一种方式Callable.docx 红黑树简介.docx 线程死锁及解决办法.docx 线程锁之重入锁.docx 线程间的...
Geoserver源码解读三 GeoServerBasePage
最新发布
Yuanben_wuxin的博客
06-19 652
GeoServerBasePage 登录
【仿真建模-anylogic】FlowchartPort原理解析
zhaoyaxuan001的博客
06-14 392
FlowchartPort是流图组件端口的基类，一般不会直接使用；如果需要自行封装组件库时会用到；FlowchartPort继承Port类，并定义了一系列抽象函数；用于输入端口判定此刻是否不能接收Agent。用于输出端口判定是否有Agent准备离开。判定端口是否发生错误。
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
lx_nhs的博客
06-12 563
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
SpringBoot之请求映射原理
好记性不如烂笔头
06-12 1275
我们发出的请求，SpringMVC是如何精准定位到那个Controller以及具体方法？其实这都是 HandlerMapping 发挥的作用，这篇博文我们以 RequestMappingHandlerMapping 为例并结合源码一步步进行分析。默认 HandlerMapping 主要定义在和其祖父类中获取所有类型是 Object 的 beans，并且 beanName 不以开头根据 beanName 获取 beanType如果 beanType 上存在注解则进行处理。
微型操作系统内核源码详解系列四（3）：操作系统调度算法（FreeRTOS内核篇上）
2301_77061352的博客
06-12 873
-uxTopPriority，被设定为是代表最大优先级的数字，自减操作代表从就绪列表最后一个链表（优先级最高的链表）开始查找，直到找到任务链表不为空的优先级任务，那么这个任务肯定也是所有任务中优先级最大的任务，然后获取这个任务的TCB并更新pxCurrentTCB（切换的具体函数），最后更新uxTopReadyPriority的值。容笔者说一下个人看法，从c语言和数据结构算法的层面学习，只能说是舍本逐末，透过Freertos这个小型系统，窥见庞大的操作系统架构的一角，这才是我们学习的重点。
【Hydro】SCS-CN方法中径流曲线数的确定（下）
```On Earth, Be Water, By Coding```
06-11 146
在[【Hydro】SCS-CN方法中径流曲线数的确定（上）](https://blog.csdn.net/qq_25262697/article/details/133796329)中已经介绍了SCS-CN在SWAT和HMS中的应用，以下会补充SCS-CN在XPSWMM、InfoWorks ICM中的应用。以及使用软件计算SCS-CN的步骤。
从零手写实现 nginx-20-placeholder 占位符 $
06-12 1166
大家好，我是老马。很高兴遇到你。我们为 java 开发者实现了 java 版本的 nginx如果你想知道 servlet 如何处理的，可以参考我的另一个项目：手写从零实现简易版 tomcatminicat除了内置变量，Nginx 还允许用户自定义变量。自定义变量可以在set指令中定义。在这个例子中，定义了一个自定义变量，其值为，并在响应中返回这个值。Nginx 支持占位符的主要目的是提供更高的灵活性和动态性，使其能够适应各种复杂的应用场景和需求。
【使用ObjectSizeCalculator计算对象内存大小】
歪比巴卜
06-12 194
使用ObjectSizeCalculator计算对象内存大小的总结
ArrayList扩容源码分析
03-30
下面我们来看一下ArrayList扩容的源码实现。 在ArrayList中，扩容是由ensureCapacity方法实现的。当元素数量超过了数组容量时，该方法会调用grow方法来扩容数组。 ``` private void ensureCapacityInternal(int ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值