Iterator、ListIterator 使用时的注意点

最新推荐文章于 2023-04-18 13:39:20 发布
最新推荐文章于 2023-04-18 13:39:20 发布
阅读量502 收藏 1
点赞数 1
分类专栏： 源码 java 文章标签： java arraylist iterator
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_20919883/article/details/120278318
版权
本文详细介绍了Java集合框架中的Iterator和ListIterator接口，包括它们的功能、使用方法以及常见陷阱。重点讲解了next()、previous()、remove()、set()和add()等操作的细节，并通过代码示例展示了这些方法的正确和错误用法。同时，分析了ArrayList和LinkedList中Iterator的实现，强调了并发修改检查和游标管理的重要性。

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

Iterator 是集合框架的重要组成部分，用来封装集合的遍历。ListIterator 扩展了 Iterator，添加了一些针对 List 的方法，比如向前遍历、添加、更新。同时迭代器在使用时会有一些坑。

Iterator

简介、测试

public interface Iterator<E> {
    /**
     * 迭代器没有到达末尾则返回 true
     */
    boolean hasNext();

    /**
     * 返回下一个元素，或者抛出异常 NoSuchElementException（已经到达末尾时）
     */
    E next();

    /**
     * 删除迭代器最后一次返回的元素，或者抛出异常 IllegalStateException 
     */
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }

    /**
     * 对每个剩余元素执行给定的操作
     */
    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

remove() 方法需要特别注意，它的功能是删除迭代器最后一次返回的元素，且每次调用 next() 方法后只能调用一次 remove() 方法，最后一次返回的元素指的是：

  • next() 方法返回的元素
  • forEachRemaining() 迭代的最后一个元素，大概率是集合的最后一个元素（但发生了并发修改就可能不是集合的最后一个元素了，详见下面的源码分析）

remove 注意点：

  • 调用 remove() 方法前必须先调用 next() 或 forEachRemaining() 方法
  • 每次 next() 调用后最多只能调用一次 remove() 方法

以下代码会报错，因为调用 remove() 方法前没有调用 next() 方法，导致不知道要删除哪个元素：

public static void main(String[] args) {
    List<Integer> list = Arrays.asList(1, 2, 3, 4);
    Iterator<Integer> iterator = list.iterator();
    iterator.remove();
}

Exception in thread "main" java.lang.IllegalStateException
	at java.util.ArrayList$Itr.remove(ArrayList.java:874)
	at com.example.heima.itr.ItrTest.main(ItrTest.java:21)

以下代码同样会报错（在第二次调用 remove() 方法时），即使先调用了两次 next() 方法，因为 remove() 方法只会删除上一次返回的元素，不会关注上上次返回的：

public static void main(String[] args) {
    List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
    Iterator<Integer> iterator = list.iterator();
    iterator.next();
    iterator.next();
    iterator.remove();
    System.out.println(list);
    iterator.remove();
}

[1, 3, 4]
Exception in thread "main" java.lang.IllegalStateException
	at java.util.ArrayList$Itr.remove(ArrayList.java:874)
	at com.example.heima.itr.ItrTest.main(ItrTest.java:23)

以下代码会正常执行：

public static void main(String[] args) {
    List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
    Iterator<Integer> iterator = list.iterator();
    iterator.next();
    iterator.remove();
    System.out.println(list);
    iterator.next();
    iterator.remove();
    System.out.println(list);
}

[2, 3, 4]
[3, 4]

以下代码会删除最后一个元素 “4”：

public static void main(String[] args) {
    List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
    Iterator<Integer> iterator = list.iterator();
    iterator.forEachRemaining(System.out::println);
    iterator.remove();
    System.out.println(list);
}

1
2
3
4
[1, 2, 3]

ArrayList 的 Iterator 实现

可以通过 ArrayList 的源码来更好的理解 Iterator，使用 lastRet 记录最后一次返回的元素的索引，默认值为 -1 代表没有最后一次返回的元素。next()、forEachRemaining() 方法会修改 lastRet。remove() 方法会使用并重置 lastRet：

private class Itr implements Iterator<E> {
    int cursor;       // 下一个元素的索引
    int lastRet = -1; // 最后一次返回的元素的索引，若没有则返回 -1
    int expectedModCount = modCount;	// 实例化迭代器时会记录当前 ArrayList 的 modCount，用于并发修改的检查

    Itr() {}

    // 下一个元素的索引为 size 说明到末尾了
    public boolean hasNext() {
        return cursor != size;
    }

    @SuppressWarnings("unchecked")
    public E next() {
        // 并发修改检查
        checkForComodification();
        // 记录当前的 cursor
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        // cursor++
        cursor = i + 1;
        // 使用 lastRet 记录加一之前的 cursor，即上次返回的元素的索引，由于 remove
        return (E) elementData[lastRet = i];
    }

    public void remove() {
        // 之前没有调用过 next() 方法，
        // 或之前调用过 next() 方法，但之后已经调用过 remove() 了，因为 remove() 会将 lastRet 重置为 -1
        if (lastRet < 0)
            throw new IllegalStateException();
        // 并发修改检查
        checkForComodification();

        try {
            // 删除上次返回的元素 lastRet
            ArrayList.this.remove(lastRet);
            // cursor--
            cursor = lastRet;
            // 重置 lastRet
            lastRet = -1;
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

    @Override
    @SuppressWarnings("unchecked")
    public void forEachRemaining(Consumer<? super E> consumer) {
        Objects.requireNonNull(consumer);
        final int size = ArrayList.this.size;
        int i = cursor;
        // 已经到达末尾
        if (i >= size) {
            return;
        }
        final Object[] elementData = ArrayList.this.elementData;
        // 在迭代的过程中，原始数组被变小了，说明发生了其他的结构化修改
        if (i >= elementData.length) {
            throw new ConcurrentModificationException();
        }
        // 判断条件有 modCount == expectedModCount，所以遇到并发修改会停止迭代
        while (i != size && modCount == expectedModCount) {
            consumer.accept((E) elementData[i++]);
        }
        // update once at end of iteration to reduce heap write traffic
        // 更新下一个元素的索引以及最后一次返回的元素的索引
        cursor = i;
        lastRet = i - 1;
        checkForComodification();
    }

    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}

ListIterator

简介、测试

是专门用于 List 的迭代器，允许从任意方向（正向、反向）遍历列表，在迭代期间修改列表，并获取迭代器在列表中的当前位置。ListIterator 没有当前元素；它的游标总是位于调用 previous() 返回的元素和调用 next() 返回的元素之间。对于长度为 n 的列表，迭代器有 n+1 个可能的游标位置，如下所示:

                        Element(0)   Element(1)   Element(2)   ... Element(n-1)
   cursor positions:  ^            ^            ^            ^                  ^

注意，remove() 和 set(Object) 方法不是根据游标位置定义的；而是对调用 next() 、previous() 或 forEachRemaining() 返回的最后一个元素进行操作。

public interface ListIterator<E> extends Iterator<E> {
    // Query Operations

    /**
     * 如果迭代器在正向遍历列表时有更多的元素，则返回 true。
     */
    boolean hasNext();

    /**
     * 返回列表中的下一个元素并推进游标位置。(注意，交替调用 next 和 previous 将重复返回相同的元素。)
     */
    E next();

    /**
     * 如果迭代器在反向遍历列表时有更多的元素，则返回 true
     */
    boolean hasPrevious();

    /**
     * 返回列表中的前一个元素并向后移动游标位置。(注意，交替调用 next 和 previous 将重复返回相同的元素。)
     */
    E previous();

    /**
     * 返回下次调用 next 返回的元素的索引。(如果迭代器位于列表的末尾，则返回列表大小。)
     */
    int nextIndex();

    /**
     * 返回下次调用 previous 返回的元素的索引。(如果迭代器位于列表的开头，则返回 -1。)
     */
    int previousIndex();


    // Modification Operations

    /**
     * 从列表中删除最后一个返回的元素。每次调用 next() 或 previous() 后，只能调用一次 remove()。
     * 只有在上次调用 next() 或 previous() 后没有调用 add() 时，才能进行此操作。
     */
    void remove();

    /**
     * 最后一个返回的元素替换为指定的元素。只有在对next或previous的最后一次调用之后没有调用remove或add时，才能进行此调用。
     * 只有在上次调用 next() 或 previous() 后没有调用 add() 或 remove() 时，才能进行此操作。
     */
    void set(E e);

    /**
     * 将指定的元素插入列表。元素被插入到 next() 返回的元素的前面，以及 previous() 返回的元素的后面。
     * (如果列表中不包含元素，则新元素将成为列表中唯一的元素。)
     * 在隐式游标之前插入新元素:对 next() 的后续调用将不受影响，而对 previous() 的后续调用将返回新元素。
     * (这个调用增加了一个调用 nextIndex()、previousIndex() 返回值。)
     */
    void add(E e);
}

交替调用 next 和 previous 将重复返回相同的元素。

public static void main(String[] args) {
    List<Integer> list = new LinkedList<>(Arrays.asList(1, 2, 3, 4));
    ListIterator<Integer> iterator = list.listIterator(2);
    System.out.println(iterator.next());
    System.out.println(iterator.previous());

    System.out.println(iterator.previous());
    System.out.println(iterator.next());
}

3
3
2
2

以下为隐式游标的变化：

        1   2   3   4
开始:          ^			
next:              ^    3
previous:     ^	        3
previous: ^	            2
next:         ^	        2

remove()

ListIterator 的 remove() 方法与 Iterator 相似，都是删除最后一个返回的元素。最后一次返回的元素可能是：

  • next() 方法返回的元素
  • previous() 方法返回的元素
  • forEachRemaining() 迭代的最后一个元素

注意点：

  • 调用 remove() 方法前必须先调用 next() 、previous() 或 forEachRemaining() 方法，且在上次调用上述方法后没有调用 add() ，才能执行删除。因为 add() 会推进游标，且会清除最后一个返回的元素。调用 set() 不会影响 remove()，因为 set() 不会清除最后一个返回的元素。
  • 每次以上方法调用后最多只能调用一次 remove() 方法

以下代码会报错：因为 add() 会推进游标，且会清除最后一个返回的元素，导致 remove() 找不到模目标

public static void main(String[] args) {
    List<Integer> list = new LinkedList<>(Arrays.asList(1, 2, 3, 4));
    ListIterator<Integer> iterator = list.listIterator();
    iterator.next();
    iterator.next();
    iterator.add(0);
    System.out.println(list);
    iterator.remove();
}

Exception in thread "main" java.lang.IllegalStateException
	at java.util.LinkedList$ListItr.remove(LinkedList.java:923)
	at com.example.heima.itr.ItrTest.main(ItrTest.java:20)

set()

set() 功能是替换最后一个返回的元素，前提是最后一个返回的元素必须存在，否则抛异常，和 remove() 的约束类似：

  • 调用 set() 方法前必须先调用 next() 、previous() 或 forEachRemaining() 方法，且在上次调用上述方法后没有调用 add() 、remove()，才能执行此操作。
  • 与 remove() 不同的是，set() 方法可多次调用

以下代码正常执行，因为 set() 方法可多次调用：

public static void main(String[] args) {
    List<Integer> list = new LinkedList<>(Arrays.asList(1, 2, 3, 4));
    ListIterator<Integer> iterator = list.listIterator();
    iterator.next();
    System.out.println(list);
    iterator.set(100);
    System.out.println(list);
    iterator.set(200);
    System.out.println(list);
}

[1, 2, 3, 4]
[100, 2, 3, 4]
[200, 2, 3, 4]

以下代码会报错，因为 remove() 会将游标左移，并清除最后一个返回的元素：

public static void main(String[] args) {
    List<Integer> list = new LinkedList<>(Arrays.asList(1, 2, 3, 4));
    ListIterator<Integer> iterator = list.listIterator();
    iterator.next();
    iterator.next();
    System.out.println(list);
    iterator.remove();
    System.out.println(list);
    iterator.set(100);
    System.out.println(list);
}

[1, 2, 3, 4]
[1, 3, 4]
Exception in thread "main" java.lang.IllegalStateException
	at java.util.LinkedList$ListItr.set(LinkedList.java:937)
	at com.example.heima.itr.ItrTest.main(ItrTest.java:21)

将上面的 remove 换成 add() 也会报错，因为 add() 会推进游标，且清除最后一个返回的元素：

public static void main(String[] args) {
    List<Integer> list = new LinkedList<>(Arrays.asList(1, 2, 3, 4));
    ListIterator<Integer> iterator = list.listIterator();
    iterator.next();
    iterator.next();
    System.out.println(list);
    iterator.add(0);
    System.out.println(list);
    iterator.set(100);
    System.out.println(list);
}

[1, 2, 3, 4]
[1, 2, 0, 3, 4]
Exception in thread "main" java.lang.IllegalStateException
	at java.util.LinkedList$ListItr.set(LinkedList.java:937)
	at com.example.heima.itr.ItrTest.main(ItrTest.java:21)

add()

  • 元素被插入到 next() 返回的元素的前面，以及 previous() 返回的元素的后面。
  • 如果列表中不包含元素，则新元素将成为列表中唯一的元素。
  • 在隐式游标之前插入新元素:对 next() 的后续调用将不受影响，而对 previous() 的后续调用将返回新元素。
  • 这个调用增加了一个调用 nextIndex()、previousIndex() 返回值。
public static void main(String[] args) {
    List<Integer> list = new LinkedList<>(Arrays.asList(1, 2, 3, 4));
    ListIterator<Integer> iterator = list.listIterator();
    System.out.println(list);
    iterator.next();
    System.out.println("nextIndex：" + iterator.nextIndex());
    System.out.println("previousIndex：" + iterator.previousIndex());
    iterator.add(0);
    System.out.println(list);
    System.out.println("nextIndex：" + iterator.nextIndex());
    System.out.println("previousIndex：" + iterator.previousIndex());
    System.out.println("next：" + iterator.next());
    System.out.println("previous：" + iterator.previous());
}

[1, 2, 3, 4]
nextIndex：1
previousIndex：0
[1, 0, 2, 3, 4]
nextIndex：2
previousIndex：1
next：2
previous：2

游标的变化：

            1   2   3   4
开始:      ^	 			
next:	      ^					
            1   2   3   4
add:         0^						// 在游标的前面插入，游标前面的元素多了一个，所以要推进游标
            1   0	2   3   4
				  ^
next:                 ^			2
previous:         ^				2

ArrayList 的 ListIterator 实现

private class ListItr extends Itr implements ListIterator<E> {
    ListItr(int index) {
        super();
        cursor = index;
    }

    // cursor 代表下一个元素的索引，cursor == 0 说明已经到达头部了，一个没有上一个了
    public boolean hasPrevious() {
        return cursor != 0;
    }

    public int nextIndex() {
        return cursor;
    }

    public int previousIndex() {
        return cursor - 1;
    }

    @SuppressWarnings("unchecked")
    public E previous() {
        // 并发修改检查
        checkForComodification();
        // cursor 代表下一个元素的索引
        // 隐式游标始终位于 previous 与 next 之间
        // 索引 previous = next - 1 = cursor - 1
        int i = cursor - 1;
        if (i < 0)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i;
        // 记录上次返回的元素的索引 lastRet
        return (E) elementData[lastRet = i];
    }

    public void set(E e) {
        // 判断最后一次返回的元素是否存在
        if (lastRet < 0)
            throw new IllegalStateException();
        checkForComodification();

        try {
            // 更新，且没有重置 lastRet，所以能够重复调用 set
            ArrayList.this.set(lastRet, e);
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

    public void add(E e) {
        checkForComodification();

        try {
            int i = cursor;
            ArrayList.this.add(i, e);
            // 推进游标
            cursor = i + 1;
            // 重置 lastRet，清除最后一次返回的元素
            lastRet = -1;
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }
}

总结

  • 游标总是位于调用 previous() 返回的元素和调用 next() 返回的元素之间

  • 交替调用 next() 和 previous() 将重复返回相同的元素

  • remove()、set() 需要最后一次返回的元素

  • next() 、previous()、forEachRemaining() 会创建最后一次返回的元素

  • remove()、add() 会清除最后一次返回的元素

  • set() 可多次调用

  • add() 在隐式游标的前面插入，并推进游标

Iterator 和 ListIterator 有什么区别？
weixin_39017359的博客
04-14 2808
在工作过程中我们经常会使用到迭代器，那么我们如何使用迭代器以及我们为什么要使用它；Iterator和ListIterator之间的区别是 什么。下面就是我个人的一些理解。除了让自己巩固基础外；希望能为大家提供一些帮助。 我们在使用集合的时候都会使用到迭代器（Iterator），迭代器依附与集合对象存在，本身不具备装载对象的能力。 迭代器的好处是 1.集合本身提供了访问对象各个元素的途径，...
20：Iterator、iterator、Iterable、ListIterator、listIterator的使用及区别及源码中它们的具体实现：
随手记记，加深印象。
06-19 454
Iterable 是ArrayList和LinkedList的共同父接口。 而 iterator 是Iterable 接口中的 一个抽象方法：Iterator 是 Iterable 接口的 iterator 抽象方法的返回值。 由 AbstractList抽象父类进行了实现了 iterator方法，AbstractList的 Itr 内部类实现了 Iterator接口。只有ArrayList进行了重写，ArrayList中 Itr 内部类重写实现了 Iterator接口。 ListIterator 是 It
C++标准库---list使用注意事项
lanzh_
11-29 2200
list使用需要注意的几点： 1.list不支持随机存取，即如果你要存取第5个元素，你必须顺着串链一一爬过前4个元素，所以在list中随机遍历任意元素，是很缓慢的行为； 2.任何位置（不只是两端）执行元素的安插和删除都非常快，始终是常数时间内完成，因为无需移动任何其他元素，实际上内部只是进行了一些指针操作而已； 3.安插和删除动作并不会造成指向其他元素的各个pointers,referenc
list循环遍历remove的坑
君当自强
02-10 6279
list循环遍历remove的坑
java.lang.IllegalStateException异常原因和解决
weixin_44304815的博客
04-18 5963
Iterator remove 引发 java.lang.IllegalStateException异常
springboot连接数据源的坑
qq_41501190的博客
12-13 462
配置数据源 spring: datasource: data-username: root data-password: 1511 driver-class-name: com.mysql.cj.jdbc.Driver url: jdbc:mysql://localhost:3306/springboot?characterEncoding=utf8 显示的错误 java.sql.SQLSyntaxErrorException: Access denied for
IllegalStateException
weixin_30763397的博客
08-05 200
例1 public static void main(String[]sdf){ List<String> list = new ArrayList<String>(); list.add("1"); list.add("2"); list.add("3"); list.add(...
java中Iterator和ListIterator实例详解
08-28
当调用 xxx.iterator() 或 xxx.listIterator() 方法时，迭代器指向 Iterator_one 的位置，当调用 xxx.next() 方法时，迭代器位置指向 Iterator_two 的位置。迭代器指向的位置并不是正对着元素，而是在元素之间。 ...
JAVA中ListIterator和Iterator详解与辨析(推荐)
08-30
相同点：都是迭代器，当需要对集合中元素进行遍历不需要干涉其遍历过程时，这两种迭代器都可以使用。 不同点： 1、使用范围不同，Iterator可以应用于所有的集合，Set、List和Map和这些集合的子类型。而...
java Iterator接口和LIstIterator接口分析
08-30
Java Iterator接口和ListIterator接口分析 Java Iterator接口和ListIterator接口是Java集合框架中的两个重要接口，分别用于迭代集合中的元素和列表中的元素。在本文中，我们将详细介绍Java Iterator接口和...
java中ArrayList使用remove删除元素时几种常见的问题及解决办法
sq_better的博客
02-06 3万+
JException in thread "main" java.util.ConcurrentModificationException at java.util.AbstractList$Itr.checkForComodification(Unknown Source) at java.util.AbstractList$Itr.next(Unknown Source)
ArrayList删除元素(remove())报错的原理与解决办法
没有伞的孩子只能快跑，如若不跑，只有一个结果：超过你的人回头鄙视你
10-21 1万+
作为Java大家庭中的集合类框架，List应该是平时开发中最常用的，可能有这种需求，当集合中的某些元素符合一定条件时，想要删除这个元素。如： [java] view plaincopyprint? public class ListTest {       public static void main(String[] args) {       
Java基础：ArrayList常见的删除问题和解决方案
Gongyl的博客
04-06 1148
本文主要分析在循环遍历的情况下使用ArrayList删除元素可能会导致的问题，并给出解决方案。如果有更好的解决方案请务必留言。万分感谢！ 一、要删除的元素在集合中不止一个 List<String> list = new ArrayList<>(); list.add("1"); list.add("2"); list.a...
遍历ArrayList时同时修改引发的问题
weixin_30731287的博客
11-13 416
看见一篇博客，没有写完整，于是增补了一下： 博客原文：http://www.cnblogs.com/alipayhutu/archive/2012/08/11/2634073.html 注：黄色字体为我添的 CopyOnWriteArrayList，因何而存在？ ArrayList的一个线程安全的变体，其所有可变操作（add、set等）都是通过对底层数组进行一次新的复制来实现的，代价昂贵...
java.lang.IllegalStateException异常以及解决
热门推荐
qq_43633916的博客
07-20 21万+
今天运行项目时出现的这个问题，java.lang.IllegalStateExceptio，第一次见到这个异常， 查询后 错误原因：该异常表示，当前对客户端的响应已经结束，不能在响应已经结束（或说消亡）后再向 客户端（实际上是缓冲区）输出任何内容。 具体分析：首先解释下flush()，我们知道在使用读写流的时候数据先被读入内存这个缓冲区中， 然后再写入文件，但是当数据读完时不代表数据已经写入文件完...
操作集合抛出java.lang.IllegalStateException异常的原因及其解决思路
hank4ever
04-28 1820
在Java中经常用到容器类，可以通过迭代器类Iterator来对集合中的元素进行迭代，从而对每个单独的元素进行某种操作，例如： 要删除集合中某一个不满足条件的元素，通过Iterator来删除，首先需要使用next方法迭代出集合中的元素，然后只需要调用remove方法即可。但是如果程序中不小心，造成对一次next方法执行迭代出一个元素，而执行了多于一次的remove删除操作，就会报java.l...
java.lang.IllegalStateException异常产生的原因及解决办法
baokx的专栏
06-12 4万+
异常一：java.lang.IllegalStateException：Cannot   forward   a   response   that   is   already   committed  异常二：IllegalStateException：response already commited  异常三：IllegalStateException：getOutputStream(
java遍历集合过程中删除元素注意的问题
qq_40871196的博客
08-01 976
看下面的代码： 1 2 3 4 5 6 7 8 9 10 11 12 publicstaticvoidmain(String args[]) { List<String> famous =newArrayList<String>(...
Java Iterator与ListIterator接口详解
"这篇文档详细分析了Java中的Iterator接口和ListIterator接口，是关于这两个接口的...例如，在需要插入元素或反向遍历列表时，应使用`ListIterator`。而在只需要顺序访问集合元素的简单场景下，`Iterator`则足够使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值