集合的好帮手：Collections 工具类 --《JAVA编程思想》74

最新推荐文章于 2024-03-05 16:49:18 发布
最新推荐文章于 2024-03-05 16:49:18 发布
阅读量866 收藏
点赞数 1
分类专栏： JAVA编程思想 文章标签： java Collections Collection List Map
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BaymaxCS/article/details/121435992
版权

Java 提供了原生的 java.util.Collections 工具类，里面包含了大量的静态方法服务于 Collection 的各种操作，特此记录和大家一起学习！

目录

1.返回类型安全的容器

  • 返回受到类型安全检查的容器

Collections.checkedList(List<E> list, Class<E> type)
list 为受检查的容器，type 为被检查的 class 类型

checkedList() 可以返回对容器进行安全检查的视图，当我们试图往容器中插入不正确的类型时，会抛出类型转换异常：ClassCastException ；

    public static void main(String[] args) {
        Integer[] integers = {1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6};
        ArrayList<Integer> arrayList = new ArrayList<>(Arrays.asList(integers));
        List list = arrayList;
        list.add("a");
        System.out.println(list);
        List<Integer> typeSafeList = Collections.checkedList(arrayList, Integer.class);
        list = typeSafeList;
        list.add("b");
    }

[1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, a]
Exception in thread "main" java.lang.ClassCastException: Attempt to insert class java.lang.String element into collection with element type class java.lang.Integer
	at java.util.Collections$CheckedCollection.typeCheck(Collections.java:3037)
	at java.util.Collections$CheckedCollection.add(Collections.java:3080)
	at mtn.baymax.charpter17.CollectionsExpand.main(CollectionsExpand.java:20)

相同的方法类似还有:

  • 返回安全类型检查的 Colleciton

checkedCollection(Collection<E> c, Class<E> type)

  • 返回安全类型检查的 Map

checkedMap(Map<K, V> m, Class<K> keyType, Class<V> valueType)

  • 返回安全类型检查的 Set

checkedSet(Set<E> s, Class<E> type)

  • 返回安全类型检查的 SortedMap

checkedSortedMap(SortedMap<K, V> m, Class<K> keyType, Class<V> valueType)

  • 返回安全类型检查的 SortedSet

checkedSortedSet(SortedSet<E> s, Class<E> type)

2.获取容器内最大/最小的元素

  • 返回容器内最大的元素

max(Collection<? extends T> coll)

  • 返回容器内最小的元素

min(Collection<? extends T> coll)

    public static void main(String[] args) {
        Integer[] integers = {1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6};
        ArrayList<Integer> arrayList = new ArrayList<>(Arrays.asList(integers));
        Integer max = Collections.max(arrayList);
        System.out.println(max);
        Integer min = Collections.min(arrayList);
        System.out.println(min);
    }

6
1

我们也可以通过实现 Comparator 接口来自定义比较规则：

max(Collection<? extends T> coll, Comparator<? super T> comp)

min(Collection<? extends T> coll, Comparator<? super T> comp)

IntegerComparator 为自定义的比较规则，认为最小的即为“最大值”，故 Collections.max() 返回 1；

    public static void main(String[] args) {
        Integer[] integers = {1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6};
        ArrayList<Integer> arrayList = new ArrayList<>(Arrays.asList(integers));
        class IntegerComparator implements Comparator<Integer> {
            @Override
            public int compare(Integer i1, Integer i2) {
                if (i1 > i2) return -1;
                if (i1 < i2) return 1;
                return 0;
            }
        }
        Integer max = Collections.max(arrayList,new IntegerComparator());
        System.out.println(max);
    }

1

3.获取LIst片段第一次/最后一次出现的位置

  • 获取 List 片段第一次出现的位置

indexOfSubList(List<?> source, List<?> target) ；
source 为源容器，target 为对比的片段

  • 获取 List 片段最后一次出现的位置

lastIndexOfSubList(List<?> source, List<?> target) ；
source 为源容器，target 为对比的片段

    public static void main(String[] args) {
        Integer[] integers = {1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6};
        ArrayList<Integer> a1 = new ArrayList<>(Arrays.asList(integers));
        Integer[] ints = {4, 5, 6};
        ArrayList<Integer> a2 = new ArrayList<>(Arrays.asList(ints));
        System.out.println(Collections.indexOfSubList(a1, a2));
        System.out.println(Collections.lastIndexOfSubList(a1, a2));
    }

3
15

4.批量替换

  • 批量替换某个值

replaceAll(List list, T oldVal, T newVal)
list 为执行容器，oldVal 为旧值，newVal 为新值

    public static void main(String[] args) {
        Integer[] integers = {1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6};
        ArrayList<Integer> arrayList = new ArrayList<>(Arrays.asList(integers));
        Collections.replaceAll(arrayList,1,0);
        System.out.println(arrayList);
    }

[0, 2, 3, 4, 5, 6, 0, 2, 3, 4, 5, 6, 0, 2, 3, 4, 5, 6]

5.List倒序

  • List 倒序排列

reverse(List<?> list)

    public static void main(String[] args) {
        Integer[] integers = {1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6};
        ArrayList<Integer> arrayList = new ArrayList<>(Arrays.asList(integers));
        Collections.reverse(arrayList);
        System.out.println(arrayList);
    }

[6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1]
  • 返回逆转容器内元素自然排序规则的 Comparator

reverseOrder()

  • 将传入的 Comparator 排序规则逆转

reverseOrder(Comparator cmp)

    public static void main(String[] args) {
        Integer[] integers = {1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6};
        ArrayList<Integer> arrayList = new ArrayList<>(Arrays.asList(integers));
        Comparator<Object> comparator1 = Collections.reverseOrder();
        Collections.sort(arrayList,comparator1);
        System.out.println(arrayList);
        Comparator<Object> comparator2 = Collections.reverseOrder(comparator1);
        Collections.sort(arrayList,comparator2);
        System.out.println(arrayList);
    }

[6, 6, 6, 5, 5, 5, 4, 4, 4, 3, 3, 3, 2, 2, 2, 1, 1, 1]
[1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6]

6.打乱元素顺序

  • 打乱容器内元素顺序

shuffle(List<?> list)

  • 打乱容器内元素顺序，并指定随机来源（可确保每次运行时，获得的随机数是一致的）

shuffle(List<?> list, Random rnd)

    public static void main(String[] args) {
        Integer[] integers = {1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6};
        ArrayList<Integer> a1 = new ArrayList<>(Arrays.asList(integers));
        Collections.shuffle(a1, new Random(47));
        System.out.println(a1);
        Collections.shuffle(a1);
        System.out.println(a1);
        ArrayList<Integer> a2 = new ArrayList<>(Arrays.asList(integers));
        Collections.shuffle(a2, new Random(47));
        System.out.println(a2);
        Collections.shuffle(a2);
        System.out.println(a2);
    }


[1, 2, 2, 1, 4, 4, 2, 4, 5, 6, 3, 5, 1, 6, 6, 5, 3, 3]
[2, 1, 4, 1, 5, 6, 5, 2, 1, 4, 6, 3, 5, 3, 3, 2, 4, 6]
[1, 2, 2, 1, 4, 4, 2, 4, 5, 6, 3, 5, 1, 6, 6, 5, 3, 3]
[2, 6, 4, 6, 1, 1, 4, 5, 3, 3, 2, 4, 1, 2, 5, 5, 3, 6]

7.自定义排序

  • 自然升序

sort(List list)

  • 自定义排序

sort(List list, Comparator<? super T> c)
list 为排序容器，Comparator 为制定排序规则的实现类

    public static void main(String[] args) {
        Integer[] integers = {1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6};
        ArrayList<Integer> arrayList = new ArrayList<>(Arrays.asList(integers));
        Collections.sort(arrayList);
        System.out.println(arrayList);
        //降序排列的Comparator实现
        class IntegerComparator implements Comparator<Integer> {
            @Override
            public int compare(Integer i1, Integer i2) {
                if (i1 > i2) return -1;
                if (i1 < i2) return 1;
                return 0;
            }
        }
        Collections.sort(arrayList, new IntegerComparator());
        System.out.println(arrayList);
    }

[1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6]
[6, 6, 6, 5, 5, 5, 4, 4, 4, 3, 3, 3, 2, 2, 2, 1, 1, 1]

8.复制元素

  • 将一个 List 的元素复制到另一个 List，会替换原有容器内对应位置的元素

copy(List<? super T> dest, List<? extends T> src)
dest 为目标容器，src 为复制源

    public static void main(String[] args) {
        Integer[] ints1 = {1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6};
        ArrayList<Integer> a1 = new ArrayList<>(Arrays.asList(ints1));
        Integer[] ints2 = {11, 12, 13, 14, 15, 16};
        ArrayList<Integer> a2 = new ArrayList<>(Arrays.asList(ints2));
        Collections.copy(a1,a2);
        System.out.println(a1);
    }

[11, 12, 13, 14, 15, 16, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]

9.交换元素位置

  • 交换对应下标元素的位置，通常比自己实现的方法效率高

swap(List<?> list, int i, int j)
list 为执行容器，i 和 j 为两个位置对应的下标

    public static void main(String[] args) {
        Integer[] integers = {1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6};
        ArrayList<Integer> arrayList = new ArrayList<>(Arrays.asList(integers));
        Collections.swap(arrayList, 0, 5);
        System.out.println(arrayList);
    }


[6, 2, 3, 4, 5, 1, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]

10.填充元素

  • 使用指定元素填充容器内所有位置的元素

fill(List<? super T> list, T obj)
list 为执行容器， obj 为填充对象

    public static void main(String[] args) {
        Integer[] integers = {1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6};
        ArrayList<Integer> arrayList = new ArrayList<>(Arrays.asList(integers));
        Collections.fill(arrayList, 0);
        System.out.println(arrayList);
    }

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

11.快速构建List

  • 返回指定长度、由 T 构成的 List

<T> List<T> nCopies(int n, T o)
n 为容器长度，o 为填充对象

    public static void main(String[] args) {
        List<Integer> integers = Collections.nCopies(10, 12);
        System.out.println(integers);
        List<Double> doubles = Collections.nCopies(10, 2.4);
        System.out.println(doubles);
        List<String> strings = Collections.nCopies(10, "A");
        System.out.println(strings);
    }

[12, 12, 12, 12, 12, 12, 12, 12, 12, 12]
[2.4, 2.4, 2.4, 2.4, 2.4, 2.4, 2.4, 2.4, 2.4, 2.4]
[A, A, A, A, A, A, A, A, A, A]

12.判断元素是否有交集

  • 判断两个容器是否有交集，当没有任何相同的元素时返回 true ，否则返回 false

disjoint(Collection<?> c1, Collection<?> c2)

    public static void main(String[] args) {
        Integer[] ints1 = {1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6};
        ArrayList<Integer> a1 = new ArrayList<>(Arrays.asList(ints1));
        Integer[] ints2 = {1, 2, 3, 4, 5, 6};
        ArrayList<Integer> a2 = new ArrayList<>(Arrays.asList(ints2));
        System.out.println(Collections.disjoint(a1, a2));
        Integer[] ints3 = {7, 8, 9};
        ArrayList<Integer> a3 = new ArrayList<>(Arrays.asList(ints3));
        System.out.println(Collections.disjoint(a1, a3));
    }

false
true

13.统计元素个数

  • 统计容器内相同元素的个数

frequency(Collection<?> c, Object o)
c 为执行容器，o 为需统计的对象

    public static void main(String[] args) {
        Integer[] integers = {1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6};
        ArrayList<Integer> arrayList = new ArrayList<>(Arrays.asList(integers));
        System.out.println(Collections.frequency(arrayList, 5));
    }

3

14.返回空容器

  • 返回空 List

<T> List<T> emptyList()

  • 返回空 List

<T> List<T> emptyList()

  • 返回空 List

<T> List<T> emptyList()

返回值支持指定泛型，当试图往容器添加元素时，会抛出不支持此操作的异常： UnsupportedOperationException

    public static void main(String[] args) {
        List<Object> list = Collections.emptyList();
        Map<Object, Object> map = Collections.emptyMap();
        Set<Object> set = Collections.emptySet();
        list.add("a");
    }

Exception in thread "main" java.lang.UnsupportedOperationException
	at java.util.AbstractList.add(AbstractList.java:148)
	at java.util.AbstractList.add(AbstractList.java:108)
	at mtn.baymax.charpter17.CollectionsExpand.main(CollectionsExpand.java:16)

15.返回只读容器

  • 返回不可修改的 List

<T> List <T> unmodifiableList(List<? extends T> list)

    public static void main(String[] args) {
        Integer[] integers = {1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6};
        ArrayList<Integer> arrayList = new ArrayList<>(Arrays.asList(integers));
        List<Integer> unmodifiableList = Collections.unmodifiableList(arrayList);
        unmodifiableList.add(7);
    }

当试图往不可修改的 LIst 中放入元素时，会抛出不支持的操作类型异常： UnsupportedOperationException 。

Exception in thread "main" java.lang.UnsupportedOperationException
	at java.util.Collections$UnmodifiableCollection.add(Collections.java:1055)
	at mtn.baymax.charpter17.CollectionsExpand.main(CollectionsExpand.java:16)

类似的方法还有:unmodifiableCollection() 、 unmodifiableMap() 、unmodifiableSet()；

16.返回指定元素下标

  • 根据 key 返回 List 中对应元素下标

binarySearch(List<? extends Comparable<? super T>> list, T key)
list 为执行容器，key 为存储元素

使用 binarySearch() 之前，推荐对 List 进行排序，否则当 List 中有重复元素时，无法保证查找到具体的某一个；排序后，默认只找到第一个出现的元素；

    public static void main(String[] args) {
        Integer[] integers = {1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6};
        ArrayList<Integer> arrayList = new ArrayList<>(Arrays.asList(integers));
        Collections.sort(arrayList);
        System.out.println(arrayList);
        int index = Collections.binarySearch(arrayList, 5);
        System.out.println(index);
    }

[1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6]
13

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

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

BaymaxCS
关注
专栏目录
【算法题系列】两个数组的交集的collections解法和字典解法
qq_39075632的博客
04-07 417
给定两个数组，编写一个函数来计算它们的交集。 nums1 = [4,9,5,6,1,11] nums2 = [9,4,9,8,4] 输出: [4,9] 字典解法： collections解法： 运用collections.Counter() 为方便了解看以下解释： import collections a, b = map(collections.Counter, (nums1, nums2)...
2021 Java面试真题集锦
热门推荐
GL1765852966的博客
12-26 8万+
目录 … 1 大厂面试的基本流程 17 字节跳动 17 阿里 17 腾讯 18 网易游戏 18 面试前需要准备： 18 面试中可以借鉴的套路 19 用简历争取到更多的面试机会 19 自我介绍时，立即全面抛出技术栈和亮点 20 先介绍项目背景，打消面试官疑问 21 通过说项目管理工具，说明你不仅会写代码 22 用 SPRING BOOT 项目举例，说明你的技术基本面 23 用实例说明你在内存调优方面的经验 24 展示你在数据库调优方面的经验 25 总结前文说辞 26 准备项目说辞时，更可以准备后继面试官的问
集合 Collection
qq_45063362的博客
12-13 375
集合 Collection 常用的collection的方法： Collection collection=new ArrayList(); //多态 1.add(); //往集合中添加元素 2.addAll(); //把俩个集合当中的元素放到一个集合中 3.remove(); //删除集合中（）的元素 4.clear(); //全部清空集合中的元素 5.removeAll(); //删除俩个集合中的交集元素，返回值是bollean类型 6.contains(); //判断集合中是否包含该元素 7.
HashSet去重
Knowlege的专栏
11-28 340
package org.cdp.cloud2.model.bo; import java.util.HashSet; import java.util.Set; /** * Created by Joel.Yang on 2016/9/13. */ public class CPyC013 { private Integer py013Id; private Intege
Collection 集合的交集、差集和并集
土味儿
06-16 1260
Collection集合的交集、差集、并集
python collections求取两个集合的交集
chengde6896383的专栏
07-24 439
Java高频面试题汇总（2022）
uuqaz的博客
06-20 3602
Java1. ArrayList和LinkedList的区别Array(数组)是基于索引(index)的数据结构，它使用索引在数组中搜索和读取数据是很快的。 Array获取数据的时间复杂度是O(1),但是要删除数据却是开销很大，因为这需要重排数组中的所有数据。 缺点: 数组初始化必须指定初始化的长度, 否则报错。 List—是一个有序的集合，可以包含重复的元素，提供了按索引访问的方式，它继承Collection。List有两个重要的实现类:ArrayList和LinkedList ArrayList: 可以
JAVA工程师面试题目大全_绝对值得看
tanzhouxueyuan（JAVA交流群：432764060）的博客
05-16 9372
明天或者后天面试JAVA工程师怎么办？史上最全的全劲爆的JAVA工程师面试题，不得不看？本文集互联网全部的面试题，同时提供各大公司的面试题，助你增加面试成功机会
java面试题
weixin_49277956的博客
09-05 7229
Java考试题 一：单选题 下列哪一种叙述是正确的（D ） A． abstract修饰符可修饰字段、方法和类 B． 抽象方法的body部分必须用一对大括号{ }包住 C． 声明抽象方法，大括号可有可无 D． 声明抽象方法不可写出大括号 如下代码 public class Test { public int aMethod() { static int i = 0; i++; return i; } public static void main (String args[]) { Test test
面试应急精简篇
ZM_Lucky的博客
05-28 4017
面试应急精简篇
【java】Collection求交集
峰峯的专栏
10-11 4851
集合如何求交集？Collection中retainAll如何使用？
常用工具类-Collections
m0_63622279的博客
02-05 1298
Collections类是一个工具类，它包含了一些静态方法，用于操作集合（如列表和映射）。这个类主要用于创建不可修改的集合、填充集合、替换元素等。基本每个方法都是见名知意的。下面练习几个常用的方法。
Collection 差交并集
yin__ren的博客
12-03 560
一、List 推荐阅读：java-----求两个list的交集、并集、和差集 List list1 =new ArrayList(); list1.add("1111"); list1.add("2222"); list1.add("3333"); List list2 =new ArrayList(); list2.add("3333"); list2.add("4444"); list2.add("5555"); //并集 list1.addAll(list2); //交集 list1.r
Collections集合工具类
牧羊boy的博客
06-30 273
常用方法 java.utils.Collections 是集合工具类，用来对集合进行操作。部分方法如下： public static boolean addAll(Collection c, T… elements) :往集合中添加一些元素。 public static void shuffle(List<?> list) 打乱顺序 :打乱集合顺序。 public class C...
java 集合交集_java的集合操作(交集、并集、差集)整理
weixin_39803977的博客
02-12 165
/*** 求ls对ls2的差集,即ls中有，但ls2中没有的** @param ls* @param ls2* @return*/public static List diff(List ls, List ls2) {List list = new ArrayList(Arrays.asList(new Object[ls.size()]));Collections.copy(list, ls);...
两个list集合的交集并集差集
公众号：Java与交易 获取更多教程
06-21 5098
List<String> list1=new ArrayList<String>(); list1.add("1111"); list1.add("2222"); list1.add("3333"); list1.add("4444"); List<String> list2 =new ArrayList<Stri...
Collections验证两个集合是否存在交集关系和包含关系的方法
最新发布
weixin_43873239的博客
03-05 512
转换的成本（O(n)）在第一次转换后就可以通过后续操作中的性能提升来弥补。进行操作通常会更高效，尤其是在处理大型数据集时。的形式存在，而你需要频繁地进行包含关系的检查，那么将这些。方法来验证一个集合是否包含另一个集合的所有元素时，选择。）中，元素的查找时间复杂度为O(1)。因此，整个操作的时间复杂度大致为O(n)，其中n是。中的元素，只需要常数时间就可以检查它是否存在于。的操作时间复杂度可能达到O(n*m)，其中n是。中，查找元素的时间复杂度为O(n)。这在两个列表都很大时会非常慢。因此，如果你已经有了。
Java判断两个集合是否具有交集以及如何获得交集
studio_1的博客
03-31 1万+
全限定名为：org.apache.commons.collections.CollectionUtils，两个集合有交集会返回true，否则会返回false，跟Collections.disjoint相反。全限定名为：cn.hutool.core.collection.CollectionUtil，两个集合有交集会返回true，否则会返回false，跟Collections.disjoint相反。和“一.4”那样，有两种方式可以得到两集合的交集。和“二.1”一样，这样也是不能去重的。
java中viewList的用法_Java Collections checkedList()用法及代码示例
weixin_33498283的博客
02-28 208
java.util.Collections类的checkedList()方法用于返回指定列表的动态类型安全视图。如果指定的列表是可序列化的，则返回的列表将是可序列化的。由于将null视为任何引用类型的值，因此只要后备列表允许，返回的列表就允许插入null元素。用法:public static ListcheckedList(List list, Class type)参数：此方法将以下参数作为参...
Java集合操作：Collections工具类详解
`java.util.Collections` 是一个实用工具类，它提供了多种对集合进行操作的方法，如添加元素、打乱顺序、排序等。下面我们将详细探讨这些知识点。 1. 往集合中一次性添加多个元素 `Collections.addAll()` 方法允许...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

BaymaxCS

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

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

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

打赏作者

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

抵扣说明：

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

余额充值