RxJava3 过滤型操作符

于 2022-11-19 23:41:54 发布
阅读量471 收藏 1
点赞数 1
分类专栏： # RxJava 文章标签： rxjava android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bigfc/article/details/127941659
版权

通过具体的示例，学习每个操作符的用法~

1.Debounce

Debounce操作符可以防止频繁发送数据，仅当特定时间间隔已过而未发射另一个项目时，才会从Observable发射项目。

示例：

Observable.interval(3, TimeUnit.SECONDS)
    //仅当特定时间间隔已过而未发射另一个项目时，才会从Observable发射项目
    //此处如果debounce设置的时间比interval的间隔大的话，就不会发送任何事件
    .debounce(2, TimeUnit.SECONDS)
    .subscribe(object : Observer<Long> {
        override fun onSubscribe(d: Disposable) {
            Log.e(TAG, "---------onSubscribe---------")
        }
        override fun onNext(t: Long) {
            Log.e(TAG, "---------onNext--------${t}-")
        }
        override fun onError(e: Throwable) {
            Log.e(TAG, "---------onError---------")
        }
        override fun onComplete() {
            Log.e(TAG, "---------onComplete---------")
        }
    })

输出结果：

//interval设置间隔3秒发送一次数据，大于debounce设置的2秒，所以数据正常发送。如果debounce设置的时间比interval的间隔大的话，就不会发送任何事件。

2022-11-19 20:51:31.551  E/FilterOperator: ---------onSubscribe---------
2022-11-19 20:51:36.556  E/FilterOperator: ---------onNext--------0-
2022-11-19 20:51:39.554  E/FilterOperator: ---------onNext--------1-
2022-11-19 20:51:42.554  E/FilterOperator: ---------onNext--------2-

2.Distinct ⭐️

Distinct运算符通过仅允许尚未发出的项目通过来过滤Observable，也就是可以去重。

示例：

Observable.just(1, 2, 2, 3, 4, 4, 5)
    .distinct()
    .subscribe(object : Observer<Int> {
        override fun onSubscribe(d: Disposable) {
            Log.e(TAG, "---------onSubscribe---------")
        }
        override fun onNext(t: Int) {
            Log.e(TAG, "---------onNext--------${t}-")
        }
        override fun onError(e: Throwable) {
            Log.e(TAG, "---------onError---------")
        }
        override fun onComplete() {
            Log.e(TAG, "---------onComplete---------")
        }
    })

输出结果：

2022-11-19 20:57:48.863 E/FilterOperator: ---------onSubscribe---------
2022-11-19 20:57:48.863 E/FilterOperator: ---------onNext--------1-
2022-11-19 20:57:48.863 E/FilterOperator: ---------onNext--------2-
2022-11-19 20:57:48.863 E/FilterOperator: ---------onNext--------3-
2022-11-19 20:57:48.863 E/FilterOperator: ---------onNext--------4-
2022-11-19 20:57:48.863 E/FilterOperator: ---------onNext--------5-
2022-11-19 20:57:48.863 E/FilterOperator: ---------onComplete---------

3.DistinctUntilChanged

DistinctUntilChanged运算符也是用来去重的操作符，阻止连续重复事件的发送。

示例：

Observable.just(1, 2, 3, 3, 2, 1)
    .distinctUntilChanged()
    .subscribe(object : Observer<Int> {
        override fun onSubscribe(d: Disposable) {
            Log.e(TAG, "---------onSubscribe---------")
        }
        override fun onNext(t: Int) {
            Log.e(TAG, "---------onNext--------${t}-")
        }
        override fun onError(e: Throwable) {
            Log.e(TAG, "---------onError---------")
        }
        override fun onComplete() {
            Log.e(TAG, "---------onComplete---------")
        }
    })

输出结果：

2022-11-19 20:57:48.864 E/FilterOperator: ---------onSubscribe---------
2022-11-19 20:57:48.864 E/FilterOperator: ---------onNext--------1-
2022-11-19 20:57:48.864 E/FilterOperator: ---------onNext--------2-
2022-11-19 20:57:48.864 E/FilterOperator: ---------onNext--------3-
2022-11-19 20:57:48.864 E/FilterOperator: ---------onNext--------2-
2022-11-19 20:57:48.864 E/FilterOperator: ---------onNext--------1-
2022-11-19 20:57:48.865 E/FilterOperator: ---------onComplete---------

4.ElementAt

ElementAt运算符在源Observable发射的项目序列中提取位于指定索引位置的项目，并将该项目作为其唯一发射，其中索引位置从0开始。

示例：

Observable.just(1, 2, 3, 4, 5)
    // index 从0开始
    .elementAt(3)
    .subscribe(object : MaybeObserver<Int> {
        override fun onSuccess(t: Int) {
            //找到值走onSuccess
            Log.e(TAG, "---------onSuccess--------${t}-")
        }
        override fun onSubscribe(d: Disposable) {
            Log.e(TAG, "---------onSubscribe---------")
        }
        override fun onError(e: Throwable) {
            Log.e(TAG, "---------onError---------")
        }
        override fun onComplete() {
            //找不到值走onComplete
            Log.e(TAG, "---------onComplete---------")
        }

    })

输出结果：

//此处如果指定索引的值存在，则会走到onSuccess并获得发射的值；如果索引对应的值不存在，则会走到onComplete。

2022-11-19 21:26:33.115 E/FilterOperator: ---------onSubscribe---------
2022-11-19 21:26:33.115 E/FilterOperator: ---------onSuccess--------4-

示例2：

Observable.just(1, 2, 3, 4, 5)
    // index 从0开始
    .elementAt(6, 100)
    .subscribe(object : SingleObserver<Int> {
        override fun onSubscribe(d: Disposable) {
            Log.e(TAG, "---------onSubscribe---------")
        }
        override fun onSuccess(t: Int) {
            //找到值，返回值；找不到，返回默认值
            Log.e(TAG, "---------onSuccess--------${t}-")
        }
        override fun onError(e: Throwable) {
            Log.e(TAG, "---------onError---------")
        }
    })

输出结果：

//提供默认值，索引对应的值不存在，则会发送默认值，所以都会走到onSuccess。

2022-11-19 21:26:33.112 E/FilterOperator: ---------onSubscribe---------
2022-11-19 21:26:33.112 E/FilterOperator: ---------onSuccess--------100-

5.Filter⭐️

Filter运算符通过自定义条件函数来过滤符合条件的事件，仅发送符合条件的事件到下游。

示例：

Observable.just(1, 2, 3, 4, 5)
    .filter(object : Predicate<Int> {
        override fun test(t: Int): Boolean {
            return t % 2 != 0
        }
    })
    .subscribe(object : Observer<Int> {
        override fun onSubscribe(d: Disposable) {
            Log.e(TAG, "---------onSubscribe---------")
        }
        override fun onNext(t: Int) {
            Log.e(TAG, "---------onNext--------${t}-")
        }
        override fun onError(e: Throwable) {
            Log.e(TAG, "---------onError---------")
        }
        override fun onComplete() {
            Log.e(TAG, "---------onComplete---------")
        }
    })

输出结果：

2022-11-19 21:42:12.492 E/FilterOperator: ---------onSubscribe---------
2022-11-19 21:42:12.492 E/FilterOperator: ---------onNext--------1-
2022-11-19 21:42:12.492 E/FilterOperator: ---------onNext--------3-
2022-11-19 21:42:12.492 E/FilterOperator: ---------onNext--------5-
2022-11-19 21:42:12.492 E/FilterOperator: ---------onComplete---------

6.First⭐️

 仅发射可观测对象发射的第一个事件。

示例：

Observable.just(1, 2, 3, 4, 5)
    .first(100)
    .subscribe(object:SingleObserver<Int>{
        override fun onSubscribe(d: Disposable) {
            Log.e(TAG, "---------onSubscribe---------")
        }
        override fun onSuccess(t: Int) {
            Log.e(TAG, "---------onSuccess--------${t}-")
        }
        override fun onError(e: Throwable) {
            Log.e(TAG, "---------onError---------")
        }
    })

输出结果：

2022-11-19 22:58:47.456 E/FilterOperator: ---------onSubscribe---------
2022-11-19 22:58:47.456 E/FilterOperator: ---------onSuccess--------1-

示例2：

Observable.empty<Int>()
    .firstElement()
    .subscribe(object : MaybeObserver<Int> {
        override fun onSuccess(t: Int) {
            //找到值走onSuccess
            Log.e(TAG, "---------onSuccess--------${t}-")
        }
        override fun onSubscribe(d: Disposable) {
            Log.e(TAG, "---------onSubscribe---------")
        }
        override fun onError(e: Throwable) {
            Log.e(TAG, "---------onError---------")
        }
        override fun onComplete() {
            //找不到值走onComplete
            Log.e(TAG, "---------onComplete---------")
        }
    })

输出结果：

2022-11-19 22:58:47.459 E/FilterOperator: ---------onSubscribe---------
2022-11-19 22:58:47.459 E/FilterOperator: ---------onComplete---------

7.IgnoreElements

忽略当前Observable发出的所有项，仅调用onComplete或onError。

示例:

Observable.just(1, 2, 3, 4, 5)
    .ignoreElements()
    .subscribe(object : CompletableObserver {
        override fun onSubscribe(d: Disposable) {
            Log.e(TAG, "---------onSubscribe---------")
        }
        override fun onError(e: Throwable) {
            Log.e(TAG, "---------onError---------")
        }
        override fun onComplete() {
            Log.e(TAG, "---------onComplete---------")
        }
    })

输出结果：

2022-11-19 23:07:12.933 E/FilterOperator: ---------onSubscribe---------
2022-11-19 23:07:12.933 E/FilterOperator: ---------onComplete---------

8.Last

仅发射可观测对象发射的最后一个事件。

示例： 

Observable.empty<Int>()
    .last(100)
    .subscribe(object : SingleObserver<Int> {
        override fun onSuccess(t: Int) {
            //找到值，返回值；找不到，返回默认值
            Log.e(TAG, "---------onSuccess--------${t}-")
        }
        override fun onSubscribe(d: Disposable) {
            Log.e(TAG, "---------onSubscribe---------")
        }
        override fun onError(e: Throwable) {
            Log.e(TAG, "---------onError---------")
        }

    })

输出结果：

2022-11-19 23:10:25.363 E/FilterOperator: ---------onSubscribe---------
2022-11-19 23:10:25.363 E/FilterOperator: ---------onSuccess--------100-

 9.Simple

在周期性时间间隔内发射可观测目标发射的最新项目。

示例：

Observable.interval(1,TimeUnit.SECONDS)
    .sample(3, TimeUnit.SECONDS)
    .subscribe(object : Observer<Long> {
        override fun onSubscribe(d: Disposable) {
            Log.e(TAG, "---------onSubscribe---------")
        }
        override fun onNext(t: Long) {
            Log.e(TAG, "---------onNext--------${t}-")
        }
        override fun onError(e: Throwable) {
            Log.e(TAG, "---------onError---------")
        }
        override fun onComplete() {
            Log.e(TAG, "---------onComplete---------")
        }
    })

输出结果：

// 输出间隔3秒

2022-11-19 23:15:09.251 E/FilterOperator: ---------onSubscribe---------
2022-11-19 23:15:12.253 E/FilterOperator: ---------onNext--------2-
2022-11-19 23:15:15.253 E/FilterOperator: ---------onNext--------5-
2022-11-19 23:15:18.253 E/FilterOperator: ---------onNext--------7-
2022-11-19 23:15:21.253 E/FilterOperator: ---------onNext--------10-
2022-11-19 23:15:24.252 E/FilterOperator: ---------onNext--------13-
2022-11-19 23:15:27.253 E/FilterOperator: ---------onNext--------16-

...

 10.Skip

跳过前多少个事件的发送

示例：

Observable.interval(1,TimeUnit.SECONDS)
    .take(5)
    //跳过前三个事件
    .skip(3)
    .subscribe(object : Observer<Long> {
        override fun onSubscribe(d: Disposable) {
            Log.e(TAG, "---------onSubscribe---------")
        }
        override fun onNext(t: Long) {
            Log.e(TAG, "---------onNext--------${t}-")
        }
        override fun onError(e: Throwable) {
            Log.e(TAG, "---------onError---------")
        }
        override fun onComplete() {
            Log.e(TAG, "---------onComplete---------")
        }
    })

输出结果：

2022-11-19 23:23:10.199 E/FilterOperator: ---------onSubscribe---------
2022-11-19 23:23:14.201 E/FilterOperator: ---------onNext--------3-
2022-11-19 23:23:15.201 E/FilterOperator: ---------onNext--------4-
2022-11-19 23:23:15.201 E/FilterOperator: ---------onComplete---------

示例2：跳过前多少秒的事件发送

Observable.interval(1,TimeUnit.SECONDS)
    .take(5)
    //跳过前3秒
    .skip(3, TimeUnit.SECONDS)
    .subscribe(object : Observer<Long> {
        override fun onSubscribe(d: Disposable) {
            Log.e(TAG, "---------onSubscribe---------")
        }
        override fun onNext(t: Long) {
            Log.e(TAG, "---------onNext--------${t}-")
        }
        override fun onError(e: Throwable) {
            Log.e(TAG, "---------onError---------")
        }
        override fun onComplete() {
            Log.e(TAG, "---------onComplete---------")
        }
    })

输出结果：

2022-11-19 23:25:12.946 E/FilterOperator: ---------onSubscribe---------
2022-11-19 23:25:16.949 E/FilterOperator: ---------onNext--------3-
2022-11-19 23:25:17.949 E/FilterOperator: ---------onNext--------4-
2022-11-19 23:25:17.949 E/FilterOperator: ---------onComplete---------

11.SkipLast

跳过最后多少个事件的发送。

示例：

Observable.interval(1,TimeUnit.SECONDS)
    .take(5)
//      //跳过最后5秒
//      .skipLast(5, TimeUnit.SECONDS)
    //跳过后三个事件
    .skipLast(3)
    .subscribe(object : Observer<Long> {
        override fun onSubscribe(d: Disposable) {
            Log.e(TAG, "---------onSubscribe---------")
        }
        override fun onNext(t: Long) {
            Log.e(TAG, "---------onNext--------${t}-")
        }
        override fun onError(e: Throwable) {
            Log.e(TAG, "---------onError---------")
        }
        override fun onComplete() {
            Log.e(TAG, "---------onComplete---------")
        }
    })

输出结果：

2022-11-19 23:31:28.880 E/FilterOperator: ---------onSubscribe---------
2022-11-19 23:31:32.881 E/FilterOperator: ---------onNext--------0-
2022-11-19 23:31:33.881 E/FilterOperator: ---------onNext--------1-
2022-11-19 23:31:33.882 E/FilterOperator: ---------onComplete---------

12.Take⭐️⭐️

仅发射可观测对象发射的前n个项目。

示例：

Observable.interval(1,TimeUnit.SECONDS)
    //仅发射前5个项目
    .take(5)
//                //也可以是前5秒的
//                .take(5,TimeUnit.SECONDS)
    .subscribe(object : Observer<Long> {
        override fun onSubscribe(d: Disposable) {
            Log.e(TAG, "---------onSubscribe---------")
        }
        override fun onNext(t: Long) {
            Log.e(TAG, "---------onNext--------${t}-")
        }
        override fun onError(e: Throwable) {
            Log.e(TAG, "---------onError---------")
        }
        override fun onComplete() {
            Log.e(TAG, "---------onComplete---------")
        }
    })

输出结果：

2022-11-19 23:35:33.981 E/FilterOperator: ---------onSubscribe---------
2022-11-19 23:35:34.983 E/FilterOperator: ---------onNext--------0-
2022-11-19 23:35:35.983 E/FilterOperator: ---------onNext--------1-
2022-11-19 23:35:36.983 E/FilterOperator: ---------onNext--------2-
2022-11-19 23:35:37.982 E/FilterOperator: ---------onNext--------3-
2022-11-19 23:35:38.983 E/FilterOperator: ---------onNext--------4-
2022-11-19 23:35:38.983 E/FilterOperator: ---------onComplete---------

13.TakeLast

仅发射可观测对象发射的后n个项目。

示例：

Observable.interval(2,TimeUnit.SECONDS)
    .take(5)
    .takeLast(2)
//      .takeLast(2,TimeUnit.SECONDS)
    .subscribe(object : Observer<Long> {
        override fun onSubscribe(d: Disposable) {
            Log.e(TAG, "---------onSubscribe---------")
        }
        override fun onNext(t: Long) {
            Log.e(TAG, "---------onNext--------${t}-")
        }
        override fun onError(e: Throwable) {
            Log.e(TAG, "---------onError---------")
        }
        override fun onComplete() {
            Log.e(TAG, "---------onComplete---------")
        }
    })

输出结果：

//注意输出的时间

2022-11-19 23:38:46.164 E/FilterOperator: ---------onSubscribe---------
2022-11-19 23:38:56.166 E/FilterOperator: ---------onNext--------3-
2022-11-19 23:38:56.166 E/FilterOperator: ---------onNext--------4-
2022-11-19 23:38:56.166 E/FilterOperator: ---------onComplete---------

大脸猫6_6
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
android定时发送请求,Android异步、延迟和定时任务的简易用法
weixin_31847579的博客
05-26 653
程序猿的要求不高异步多线程延迟触发循环定时触发一、前言项目开发中一定会用到网络请求，文件读写，开启子线程进行耗时操作，延迟返回或关闭提示框，轮询接口获取处理结果，子线程发送内容到主线程更新界面等等。碰到这些问题或需求的时候，每位程序猿都会使用自己喜欢或习惯的用法来实现或界面问题。当然结果是功能完成了或问题修复了。但是代码风格的差异，使用时考虑不全，使用方法不是最优，等等多多少少存在一些瑕疵。例如：...
LiveData源码赏析三 —— 常见问题
m0_62167422的博客
06-27 917
通过postValue()方法更新LiveData数据的时候，可能存在数据丢失的情况。 我们连续调用了postValue()10次，但是结果只有最后一次的数据。 这是因为postValue()方法内部其实是将数据回调的逻辑放到了Runnable中，再post给Handler，利用Handler在主线程中更新，因此从postValue()到执行Runnable，中间是存在时间差的。在这段时间内通过postValue()方法更新数据仅仅会改变LiveData内部的值，而不会再次post一个新的Runnable。
java 2%3等于多少,RxJava 学习笔记（七） --- Filtering 过滤操作
weixin_39744316的博客
03-10 503
1. Filter —> 只发射通过了谓词测试的数据项Filter操作符使用你指定的一个谓词函数测试数据项，只有通过测试的数据才会被发射。示例代码Observable.just(1, 2, 3, 4, 5).filter(new Func1() {@Overridepublic Boolean call(Integer item) {return( item < 4 );}})....
4. RxJava过滤操作符
NorthStar的博客
07-30 610
RxJava过滤操作符
RxJava 入门（四）-- interval()的坑
热门推荐
怪咖先森的博客
03-02 1万+
大部分的操作及代码都在我上一篇博客中，这一篇我就其中比较蛋疼的问题说一下转载自一页飘舟大神的博客，Rx博客很全1. Observable.interval()不起作用的解决办法在Eclipse下测试Rxjava中的操作符interval()时出现了很奇怪的问题，怎么试都不能执行。Observable.interval(1, TimeUnit.SECONDS) .subscribe(n
RxJava3-Android-示例：RxJava 3 Android示例-从RxJava 2迁移到RxJava 3-如何在Android中使用RxJava 3
02-04
- **Utils**：可能包含一些 RxJava 3 相关的工具函数，如转换、过滤等操作符的封装。 - **Observables**：定义了特定的数据流，可以是模拟的或者从外部API获取的。 - **Schedulers**：配置和使用不同类型的调度器。 ...
rxjava-3.0.0.rar
02-21
操作符则用于对数据流进行变换、过滤、合并等操作，提供了丰富的API来简化异步编程。 在RxJava 3.0.0中，有以下几个重要的更新和改进： 1. **兼容性提升**：RxJava 3.0.0完全移除了对Java 6和Android API 14以下的...
ApplicationDemo, RxJava 各种操作符（包括线程调度）的使用范例.zip
09-17
1. **操作符**：RxJava 提供了一系列的操作符，用于对 Observable 进行转换、过滤、组合等操作。例如： - `map`：将每个源项转换为另一个值。 - `filter`：只允许符合特定条件的项通过。 - `concatMap`：将每个源...
RxJava响应式编程原理
11-14
RxJava的操作符是其强大功能的关键，它们可以对数据流进行各种转换、过滤、合并等操作。例如： 1. `map`：将每个发射的数据项转换为另一个数据项。 2. `filter`：过滤数据流，只保留满足条件的数据项。 3. `merge`...
RxJava jar
04-21
4. **Operators（操作符）**: RxJava 提供了一系列的操作符，用于转换、过滤、组合等数据流操作。例如，`map()` 可以对每个数据项进行转换，`filter()` 可以过滤掉不符合条件的数据，`merge()` 可用于合并多个 ...
RxJava之过滤操作符
行云间
05-11 1万+
涉及到列表的数据时，总是会想到一个过滤这个词语。比如，在1-100的整数中，筛选出偶数或者奇数相加，或者将前49个数相加，又或者后36个数相加，等等。在这样的场景中，不由想到将需要的数据筛选出来。在发射的Observable中，可不可以做筛选呢?     1.过滤序列 - filter     filter操作符是对源Observable产生的结果按照指定条件进行过滤，只有满足条件的结果才
关于Observable interval定时任务停止问题
weixin_34336526的博客
12-27 3302
2019独角兽企业重金招聘Python工程师标准>>> ...
Observable.interval定时执行
冰雪世界
10-22 1万+
Observable.interval方法可以定时执行自定义的逻辑，常用方法如下： /** * 定时执行 * * @param period 每次执行的间隔的时间 * @param unit 时间单位 * @return Observable对象 */ public static Observable<Long> interval(long period, Time...
Rxjava(过滤类)-Distinct
new_abc的专栏
10-31 2306
抑制（过滤掉）重复的数据项 Distinct 的过滤规则是：只允许还没有发射过的数据项通过。 demo Observable.just("a", "a", "b", "c", "a", "b") .distinct() .subscribe(new Action1() {
RxJava使用详解--过滤操作符
xiaochuanding的博客
12-19 2385
RxJava使用详解系列文章 《RxJava使用详解--创建操作符 》 《RxJava使用详解--转换操作符 》 详细的例子可以查看文章末尾的源码 这篇文章主要讲RxJava中常见的过滤操作符 1.debounce操作符 源Observable每发射一个数据项，如果在debounce规定的间隔时间内Observable没有发射新的数据项，debounce
RxJava系列教程之过滤篇（四）
你缺少想象力的博客
07-05 631
序言 上章我们讲到了rxjava最神奇的变换，本章我们开始讲rxjava中的和过滤有关的操作符，因为过滤操作符比较简单，那我就教科书式的介绍了。 过滤 1.
RxJava2 / RxAndroid2操作符distinct与distinctUntilChanged去重结果异同
chuoshao2508的博客
01-04 117
RxJava2 / RxAndroid2操作符distinct与distinctUntilChanged去重结果异同 代码例如： package zhangphil.app; import android.os.Bundle; import android.s...
Android Rxjava distinct 过滤操作符
nc_kai的博客
07-29 311
Android Rxjava distinct 过滤操作符 lambda表达式 避免不必要的手动类型声明 class Item{ var name = "" var id = "" } //初始化数据 val items = ArrayList<Item>() for(i in 1..10){ val item = Item() item.n
RxJava2.0-操作符-Creating用法
fengluoye2012的博客
01-28 378
简介 操作符是RxJava中最重要的一部分，主要分为以下几类：创建操作符（Creating ），转换操作符（Transforming），过滤操作符（Filtering），组合操作符（Combining），辅助操作符（Observable Utility），条件操作符（Conditional and Boolean），数学运算操作符（Mathematical and Aggregate），转化操作...
Wireshark过滤器支持哪些基本操作符？
最新发布
06-14
Wireshark是一个网络协议分析工具，它提供了强大的过滤器系统来帮助用户快速定位和分析网络流量。其过滤器语言支持一系列基本操作符，...3. 举例说明如何使用`contains`操作符在Wireshark过滤器中搜索特定的数据包？

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值