TreeSet、HashSet和LinkedHashSet该如何选择？ --《JAVA编程思想》 71

最新推荐文章于 2024-07-21 20:42:32 发布
原创 最新推荐文章于 2024-07-21 20:42:32 发布 · 424 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #哈希算法 #开发语言 #set

本文通过测试分析了Java集合框架中HashSet、TreeSet和LinkedHashSet在添加、查询、移除和遍历操作上的性能差异。测试结果显示，HashSet在添加和遍历上表现最优，而LinkedHashSet在查询和移除上更胜一筹，TreeSet由于排序特性在性能上相对较弱，但在需要有序集合时是理想选择。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

我们实现 Set 集合时，主要有 TreeSet、HashSet 和 LinkedHashSet 三种选择，我们该如何对它们进行选择呢？

今天和大家一起从添加、查询、移除、遍历四个方面对 Set 的子类进行测试，看看它们的性能究竟如何？

目录

0.准备工作

首先使用泛型定义一个通用的测试模板 SetTest，将需要实际测试的方法抽象为 test() ，返回值为执行测试方法所花费的时间。

public abstract class SetTest<T extends Set> {
    private T set;


    public abstract long test();

    public SetTest(T set) {
        this.set = set;
    }

    public T getSet() {
        return set;
    }

    public void setSet(T set) {
        this.set = set;
    }
    
}

再准备一个执行测试方法的工具类 SetPerformanceTest ，内部提供生成测试数据的方法 getSet() 和 打印测试信息的方法 displayHead()。

public class SetPerformanceTest {

    public static <T extends Set> T getSet(T set, int size) {
        for (int i = 0; i < size; i++) {
            set.add(i);
        }
        return set;
    }

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

接下来，开始编写不同性能场景的测试方法，后续编写的测试代码都是直接放入 SetPerformanceTest 中运行，通过计算方法执行的时间 / 操作次数 = 平均操作时间 ，来验证 Set 的性能。

1.添加

    /**
     *
     * @param set 测试容器
     * @param loops 循环次数
     * @param size 集合长度
     * @param <T> 指定继承自 Set 的泛型
     */
    public static <T extends Set> void add(T set, int loops, int size) {
        SetTest<T> setTest = new SetTest<T>(set) {
            @Override
            public long test() {
                long startTime = System.nanoTime();
                for (int i = 0; i < loops; i++) {
					//移除清空容器花费的时间，降低其对测试结果的影响
                    long clearStart = System.nanoTime();
                    set.clear();
                    long clearEnd = System.nanoTime();
                    startTime = startTime - (clearEnd - clearStart);
                    for (int j = 0; j < size; j++) {
                        set.add(j);
                    }
                }
                long endTime = System.nanoTime();
                return endTime - startTime;
            }
        };
        long operateTime = setTest.test();
        long count = loops * size;
        long avg = operateTime / count;
        System.out.println(size + "\t" + count + "\t" + avg);
    }

    public static void main(String[] args) {
        Integer[][] integers = {{10, 100000}, {30, 300000}, {50, 800000}};
        HashSet<Integer> hashSet = new HashSet<>();
        TreeSet<Integer> treeSet = new TreeSet<>();
        LinkedHashSet<Integer> linkedHashSet = new LinkedHashSet<>();
        String methodName="add";
        displayHead(hashSet, methodName);
        for (int i = 0; i < integers.length; i++) {
            add(hashSet, integers[i][0],  integers[i][1]);
        }
        System.out.println();
        displayHead(treeSet,methodName);
        for (int i = 0; i < integers.length; i++) {
            add(treeSet, integers[i][0],  integers[i][1]);
        }
        System.out.println();
        displayHead(linkedHashSet, methodName);
        for (int i = 0; i < integers.length; i++) {
            add(linkedHashSet, integers[i][0],  integers[i][1]);
        }
    }

HashSet	add
容器长度	操作次数	平均时间
100000	1000000	44
300000	9000000	19
800000	40000000	19

TreeSet	add
容器长度	操作次数	平均时间
100000	1000000	159
300000	9000000	189
800000	40000000	158

LinkedHashSet	add
容器长度	操作次数	平均时间
100000	1000000	58
300000	9000000	32
800000	40000000	26

2.查询

    /**
     * @param set   测试容器
     * @param loops 循环次数
     * @param size  集合长度
     * @param <T>   指定继承自 Set 的泛型
     */
    public static <T extends Set> void contains(T set, int loops, int size) {
        SetTest<T> setTest = new SetTest<T>(set) {
            @Override
            public long test() {
                Random random = new Random();
                long startTime = System.nanoTime();
                for (int i = 0; i < loops; i++) {
                    set.contains(random.nextInt(size));
                }
                long endTime = System.nanoTime();
                return endTime - startTime;
            }
        };
        long operateTime = setTest.test();
        long count = loops;
        long avg = operateTime / count;
        System.out.println(size + "\t" + count + "\t" + avg);
    }
    
    public static void main(String[] args) {
        Integer[][] integers = {{1000, 100000}, {3000, 300000}, {5000, 800000}};
        HashSet<Integer> hashSet = new HashSet<>();
        TreeSet<Integer> treeSet = new TreeSet<>();
        LinkedHashSet<Integer> linkedHashSet = new LinkedHashSet<>();
        String methodName="contains";
        displayHead(hashSet, methodName);
        for (int i = 0; i < integers.length; i++) {
            hashSet=getSet(hashSet,integers[i][1]);
            contains(hashSet, integers[i][0], integers[i][1]);
        }
        System.out.println();
        displayHead(treeSet, methodName);
        for (int i = 0; i < integers.length; i++) {
            treeSet=getSet(treeSet,integers[i][1]);
            contains(treeSet, integers[i][0], integers[i][1]);
        }
        System.out.println();
        displayHead(linkedHashSet, methodName);
        for (int i = 0; i < integers.length; i++) {
            linkedHashSet=getSet(linkedHashSet,integers[i][1]);
            contains(linkedHashSet, integers[i][0], integers[i][1]);
        }
    }

HashSet	contains
容器长度	操作次数	平均时间
100000	1000	976
300000	3000	238
800000	5000	272

TreeSet	contains
容器长度	操作次数	平均时间
100000	1000	1177
300000	3000	784
800000	5000	930

LinkedHashSet	contains
容器长度	操作次数	平均时间
100000	1000	134
300000	3000	177
800000	5000	263

3.移除

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

    public static void main(String[] args) {
        Integer[][] integers = {{1000, 100000}, {3000, 300000}, {5000, 800000}};
        HashSet<Integer> hashSet = new HashSet<>();
        TreeSet<Integer> treeSet = new TreeSet<>();
        LinkedHashSet<Integer> linkedHashSet = new LinkedHashSet<>();
        String methodName = "remove";
        displayHead(hashSet, methodName);
        for (int i = 0; i < integers.length; i++) {
            hashSet = getSet(hashSet, integers[i][1]);
            remove(hashSet, integers[i][0], integers[i][1]);
        }
        System.out.println();
        displayHead(treeSet, methodName);
        for (int i = 0; i < integers.length; i++) {
            treeSet = getSet(treeSet, integers[i][1]);
            remove(treeSet, integers[i][0], integers[i][1]);
        }
        System.out.println();
        displayHead(linkedHashSet, methodName);
        for (int i = 0; i < integers.length; i++) {
            linkedHashSet = getSet(linkedHashSet, integers[i][1]);
            remove(linkedHashSet, integers[i][0], integers[i][1]);
        }
    }

HashSet	remove
容器长度	操作次数	平均时间
100000	1000	681
300000	3000	268
800000	5000	286

TreeSet	remove
容器长度	操作次数	平均时间
100000	1000	1098
300000	3000	870
800000	5000	905

LinkedHashSet	remove
容器长度	操作次数	平均时间
100000	1000	132
300000	3000	177
800000	5000	256

4.遍历

    /**
     * @param set  测试容器
     * @param size 集合长度
     * @param <T>  指定继承自 Set 的泛型
     */
    public static <T extends Set> void iter(T set, int size) {
        SetTest<T> setTest = new SetTest<T>(set) {
            @Override
            public long test() {
                long startTime = System.nanoTime();
                Iterator iterator = set.iterator();
                while (iterator.hasNext()) {
                    iterator.next();
                }
                long endTime = System.nanoTime();
                return endTime - startTime;
            }
        };
        long operateTime = setTest.test();
        long count = size;
        long avg = operateTime / count;
        System.out.println(size + "\t" + size + "\t" + avg);
    }

    public static void main(String[] args) {
        Integer[] integers = {100000, 300000, 800000};
        HashSet<Integer> hashSet = new HashSet<>();
        TreeSet<Integer> treeSet = new TreeSet<>();
        LinkedHashSet<Integer> linkedHashSet = new LinkedHashSet<>();
        String methodName = "iter";
        displayHead(hashSet, methodName);
        for (int i = 0; i < integers.length; i++) {
            hashSet = getSet(hashSet, integers[i]);
            iter(hashSet, integers[i]);
        }
        System.out.println();
        displayHead(treeSet, methodName);
        for (int i = 0; i < integers.length; i++) {
            treeSet = getSet(treeSet, integers[i]);
            iter(treeSet, integers[i]);
        }
        System.out.println();
        displayHead(linkedHashSet, methodName);
        for (int i = 0; i < integers.length; i++) {
            linkedHashSet = getSet(linkedHashSet, integers[i]);
            iter(linkedHashSet, integers[i]);
        }
    }

HashSet	iter
容器长度	操作次数	平均时间
100000	100000	80
300000	300000	12
800000	800000	7

TreeSet	iter
容器长度	操作次数	平均时间
100000	100000	70
300000	300000	25
800000	800000	16

LinkedHashSet	iter
容器长度	操作次数	平均时间
100000	100000	29
300000	300000	8
800000	800000	7

5.测试结果汇总

测试项目HashSetTreeSetLinkedHashSet
添加高低中
查询中低高
移除中低高
遍历中低高

小结

  1. HashSet 和 LinkedHashSet 在各方面的性能都优于 TreeSet ，但 TreeSet 内部支持排序，当你需要一个排序好的 Set 时，推荐使用 TreeSet。
  2. LinkedHashSet 保证了元素的插入顺序，在查询、移除和遍历方面性能优于 HashSet ，但因其底层数据结构为链表，在执行插入操作的时候维护成本较高，故性能不及 HashSet 。

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

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

HashSet和TreeSet
Palpitate_fx的博客
03-18 612
目录 Set接口常用方法: HashSet： HashSet的常见操作： TreeSet: TreeSet的基本操作: HashSet是哈希表结构，主要利用HashMap的key来存储元素； TreeSet是树结构，每一个元素都是树中的一个节点，插入的元素都会进行排序； Set接口常用方法: HashSet： HashSet实现Set接口，底层由HashMap来实现，新增元素相当于HashMap的key，value默认为一个固定的Object。HashSet相当于..
Set系列集合：Hashset、LinkedHashset、TreeSet --java学习笔记
m0_71386740的博客
03-23 3086
但是，它的每个元素都额外的多了一个双链表的机制记录它前后元素的位置，会有头节点变量和尾结点变量记录第一个和最后一个元素（空间换时间）注意:如果类本身有实现Comparable接口，Treeset集合同时也自带比较器，默认使用集合自带的比较器排序。1、往哈希表添加数据时，会创建一个默认长度16的数组，默认加载因子为0.75，数组名table。JDK 8之前，新元素存入数组，占老元素位置，老元素挂下面。对于自定义类型如Student对象，Treeset默认是无法直接排序的，
比较HashSet和TreeSet
Jarry的专栏
12-05 796
代码先奉上   package com.jay.knowledge.set_study; import java.util.HashSet; import java.util.Set; import java.util.TreeSet; public class Set002 { public static void main(String[] args) { //循环次数 int
HashSet和TreeSet的比较
dengyue5705的博客
12-23 109
HashSet是基于Hash算法实现的，其性能通常优于TreeSet。我们通常都应该使用HashSet，在我们需要排序的功能时，我们才使用TreeSet 转载于:https://www.cnblogs.com/meng72ndsc/archive/2010/12/23/1914492.html...
java treeset 比较,好程序员Java培训分享treeset和hashset的区别
weixin_31182871的博客
03-13 120
好程序员Java培训分享treeset和hashset的区别首先我们来说一下HashSet。HashSet有以下特点不能保证元素的排列顺序，顺序有可能发生变化不是同步的集合元素可以是null,但只能放入一个null当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值，然后根据hashCode值来决定该对象在HashSet中存储...
TreeSet 和 HashSet区别
星空下的那个人影
05-17 738
HashSet 是采用 hash 表来实现的。其中的元素没有按顺序排列，add()、remove() 以及 contains() 等方法都是复杂度为 O(1) 的方法。 TreeSet 是采用树结构实现（红黑树算法）。元素是按顺序进行排序，但是add()、remove() 以及 contains() 等方法都是复杂度为 O(log(n)) 的方法。它还提供了一些方法来处理排序的 set，如 first()、last()、headSet()、tailSet() 等。 ...
【JAVA语言-第16话】集合框架（三）——Set、HashSet、LinkedHashSet、TreeSet集合的详细解析
Zenghaiyue_1999的博客
01-29 1420
在Java中，HashSet是一种基于哈希表的集合实现。它继承自AbstractSet类并实现了Set接口。HashSet类在内部使用哈希表来存储元素，并且不保证元素的顺序。它允许存储唯一的元素，不允许重复。HashSet提供了常量时间的查找、插入和删除操作，因此可以在大多数情况下提供高效的性能。在Java中，LinkedHashSet是一种集合类，它是HashSet的子类。它继承了HashSet的特性，同时还保持了元素的插入顺序。
java集合之Set篇——HashSet、LinkedHashSet、TreeSet的底层源码解析
2202_75483664的博客
07-21 1237
上一节结束了java集合的List篇java集合之List篇——ArrayList补充和Vector、LinkedList的底层源码-优快云博客本节说一下Set篇——HashSet、LinkedHashSet、TreeSet的底层源码解析实现Comparable接口// 自定义类 Person 实现 Comparable 接口// 构造函数// Getter 方法return age;// 重写 compareTo 方法@Override// 按年龄升序排列。
HashSet,LInkedHashSet,TreeSet比较与解读——JAVA
weixin_43698704的博客
01-13 434
目录 HashSet,LInkedHashSet,TreeSet比较与解读 1.基本性质比较 2.判定元素是否相同方法比较 3.常见函数 一、HashSet基本函数运用举例 二、LinkedHashSet 三、TreeSet HashSet,LInkedHashSet,TreeSet比较与解读 1.基本性质比较 HashSet:基于散列函数得集合，无序，可容纳null元素...
HashSet、LinkedHashSet、Treeset 的区别
pig_ning的博客
03-08 454
HashSet、LinkedHashSet、Treeset 的区别
treeset和hashset
weixin_43613968的博客
03-21 474
TreeSet的添加、删除、查找操作的时间复杂度都是O(log n)，因此在数据量较小的情况下，HashSet和TreeSet的效率差别不大，但在数据量较大的情况下，TreeSet的效率会比HashSet更高。HashSet是基于哈希表实现的，它不保证元素的顺序，也不允许重复元素。HashSet的添加、删除、查找操作都是常数时间复杂度的，因此在大量数据的情况下，HashSet的效率比较高。如果不需要保证元素的顺序，或者需要快速的添加、删除、查找操作，可以选择使用HashSet。
Hashset和Treeset的区别
m0_37235955的博客
04-19 534
Set中元素不可以重复，是无序的（这里的无序是指存入元素的先后顺序与输出元素的先后顺序不一致） HashSet： 　　①内部的数据结构是哈希表，是线程不安全的。 　　②HashSet中保证集合中元素是唯一的方法：通过对象的hashCode和equals方法来完成对象唯一性的判断。如果对象的hashCode值不同，则不用判断equals方法，就直接存到HashSet中。 　　注意：如果元素要...
HashSet、TreeSet和LinkedHashSet分别在什么时候用
hallowty的博客
06-11 503
在Java中，HashSet、TreeSet和LinkedHashSet是Set接口的不同实现类，它们在不同的使用场景下有不同的特点和优势。
set集合判断集合中是否有无元素_Set接口
weixin_39627665的博客
11-21 840
Set接口是Collection的子接口，set接口没有提供额外的方法。 Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个 Set 集合中，则添加操作失败。 Set 判断两个对象是否相同不是使用 == 运算符，而是根据 equals 方法。因此存放到Set集合中的元素一定要注意equals方法的重写。Set的常用实现类有：HashSet、TreeSet、LinkedHashSe...
Java中HashSet和TreeSet的区别
学习AI算法，请关注微信公众号：机器学习算法全栈工程师……
12-15 6499
1. HashSetHashSet有以下特点： 不能保证元素的排列顺序，顺序有可能发生变化 不是同步的 集合元素可以是null,但只能放入一个null 当向HashSet集合中存入一个元素时，HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值，然后根据 hashCode值来决定该对象在HashSet中存储位置。 简单的说，HashSet集合判断两个元素相等的标准是
HashSet和TreeSet有什么区别？
热门推荐
不见风雨怎能见彩虹
11-22 1万+
HashSet： 不能保证元素的排列顺序，顺序有可能发生变化 集合元素可以是null,但只能放入一个null HashSet底层是采用HashMap实现的 HashSet底层是哈希表实现的 TreeSet： Treeset中的数据是排好序的，不允许放入null值。 TreeSet是通过TreeMap实现的,只不过Set用的只是Map的key。 TreeSet的底层实现是采用二叉树（红-黑树）的数据...
HashSet和TreeSet用法
love_zjl的博客
11-14 890
/*  * 集合的体系：  * ----------|Collection 单列集合的根接口  * --------------|List   如果是实现了List接口的实现类，该集合类具备的特点：有序，可重复  * --------------------|ArrayList   ArrayList底层是维护了 一个Object数组实现的，特点：查询速度快，增删慢。  * ------
hashset和treeset的比较
米勺-Michelle
07-13 1490
先说下hashset： 由于hashset里面元素的位置是通过元素的哈希值来决定的，所以hashset不具备排序的功能 且hashset可以放入null，但是只能放入一个null hashset不是同步的 hashset是不能重复放入元素的，它的比较标准是调用该对象的equals方法，然后在调用其hashcode方法，所以要比较对象，应该重写对象对应类的equals方法以及hashcode
treeset、hashset、linkedhashset三者区别和联系
最新发布
03-09
<think>好的，用户想了解Java中TreeSet、HashSet和LinkedHashSet的区别与联系。首先，我需要回忆这三个集合类的特性。 TreeSet基于红黑树实现，所以元素是有序的，支持自然排序或者通过Comparator自定义排序。但插入和查询的时间复杂度都是O(log n)，相比其他两种可能稍慢。另外，TreeSet不允许null元素，这点需要注意。 HashSet是基于哈希表实现的，使用HashMap作为底层存储。它的元素是无序的，插入和查询的时间复杂度接近O(1)。不过，迭代顺序是不确定的。HashSet允许null元素，但只能有一个null，因为不允许重复。 LinkedHashSet继承自HashSet，内部通过链表维护插入顺序，因此迭代顺序是按照插入顺序来的。它的性能比HashSet略差，因为要维护链表，但比TreeSet好。同样允许null元素。 接下来，要比较它们的区别，包括底层数据结构、性能、排序特性、允许null的情况等。用户可能需要知道在不同场景下如何选择，比如需要排序就用TreeSet，需要快速访问且不关心顺序用HashSet，需要保持插入顺序用LinkedHashSet。 还要注意线程安全问题，这三个集合都不是线程安全的，如果在多线程环境下使用需要外部同步。另外，初始容量和负载因子可能对HashSet和LinkedHashSet的性能有影响，尤其是哈希冲突的情况。 可能需要提到它们都实现了Set接口，因此都不允许重复元素。在重复元素的判定上，都是根据equals()和hashCode()方法，不过TreeSet还依赖compareTo或Comparator。 最后，生成相关问题时要考虑用户可能想深入了解每个集合的内部实现，或者性能优化的方法，以及具体的使用场景举例。</think>### TreeSet、HashSet、LinkedHashSet的区别与联系 #### 1. **底层数据结构** - **TreeSet**: 基于红黑树（平衡二叉搜索树）实现，元素按自然顺序或自定义比较器排序[^1]。 - **HashSet**: 基于哈希表（`HashMap`）实现，元素无序。 - **LinkedHashSet**: 继承自`HashSet`，底层通过哈希表+双向链表维护插入顺序[^2]。 #### 2. **元素唯一性** 三者均实现`Set`接口，保证元素唯一性（依赖`equals()`和`hashCode()`方法）。 #### 3. **排序特性** - **TreeSet**: 支持自然排序（如数值、字符串）或通过`Comparator`自定义排序。例如： $$ \text{元素集合} \Rightarrow \{1, 3, 5\} \text{ 会按升序排列} $$ - **HashSet**: 无序，迭代顺序可能与插入顺序无关。 - **LinkedHashSet**: 按插入顺序迭代。 #### 4. **性能对比** | 集合类型 | 插入/删除时间复杂度 | 查询时间复杂度 | 适用场景 | |----------------|---------------------|----------------|------------------------| | **TreeSet** | $O(\log n)$ | $O(\log n)$ | 需要有序元素的场景 | | **HashSet** | $O(1)$ (平均) | $O(1)$ (平均) | 快速访问，无需排序 | | **LinkedHashSet**| $O(1)$ (平均) | $O(1)$ (平均) | 需保留插入顺序的快速访问 | #### 5. **允许`null`值** - **TreeSet**: 不允许`null`（依赖排序规则，可能抛出`NullPointerException`）。 - **HashSet/LinkedHashSet**: 允许一个`null`元素。 #### 6. **代码示例** ```java // TreeSet示例（自动排序） Set<Integer> treeSet = new TreeSet<>(); treeSet.add(3); treeSet.add(1); System.out.println(treeSet); // 输出 [1, 3] // HashSet示例（无序） Set<String> hashSet = new HashSet<>(); hashSet.add("Banana"); hashSet.add("Apple"); System.out.println(hashSet); // 可能输出 [Apple, Banana] 或其他顺序 // LinkedHashSet示例（保留插入顺序） Set<String> linkedHashSet = new LinkedHashSet<>(); linkedHashSet.add("Banana"); linkedHashSet.add("Apple"); System.out.println(linkedHashSet); // 输出 [Banana, Apple] ``` #### 7. **选择建议** - 需要排序 → **TreeSet** - 追求最高性能且无需顺序 → **HashSet** - 需保留插入顺序且快速访问 → **LinkedHashSet** ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

BaymaxCS

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

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

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

打赏作者

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

抵扣说明：

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

余额充值