Kotlin 高阶操作符

最新推荐文章于 2024-05-15 05:08:10 发布
最新推荐文章于 2024-05-15 05:08:10 发布
阅读量596 收藏 2
点赞数
分类专栏： kotlin
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33538121/article/details/108450828
版权

一、总数操作符

### any操作符

    val list = listOf(1, 3, 5, 7, 9)
    println(list.any { it > 13 })  //false
    println(list.any { it > 7 })   //true

### all操作符

    val list = listOf(1, 3, 5, 7, 9)
    println(list.all { it > 13 })  //false
    println(list.all { it > 0 })   //true

### count操作符

    val list = listOf(1, 3, 5, 7, 9)
    println(list.count { it > 7 })  //1
    println(list.count { it > 2 })  //4

### fold操作符

    在一个初始值的基础上从第一项到最后一项通过一个函数累计所有的元素

        val list = listOf(1, 3, 5, 7, 9)
        println(list.fold(2) { total, next->
            println("fold ----  $next , $total")
            next + total
        })
        log日志 
         fold ----  1 , 2
         fold ----  3 , 3	
         fold ----  5 , 6
         fold ----  7 , 11
         fold ----  9 , 18
         27

### foldRight操作符

    与 fold  一样，但顺序是从最后一项到第一项

    val list = listOf(1, 3, 5, 7, 9)
    println(list.foldRight(2) { next, total->
        println("$next , $total")
        next + total
    })
log日志 
     fold ----  9 , 2
     fold ----  7 , 11	
     fold ----  5 , 18
     fold ----  3 , 23
     fold ----  1 , 26
     27

### forEach操作符

    val list = listOf(1, 3, 5, 7, 9)
    list.forEach { print(it + 1) } //2,4,6,8,10

### forEachIndexed操作符

 	val list = listOf(1, 3, 5, 7, 9)
    list.forEachIndexed { index, value -> println("$index value is $value") }

### max操作符

    val list = listOf(1, 3, 5, 7, 9)
    println(list.max()) //9

### maxBy操作符

    根据给定的函数返回最大的一项，如果没有则返回 null

    val list = listOf(1, 3, 5, 7, 9)
    println(list.maxBy { -it }) //1

### min操作符

    返回最小的一项，如果没有则返回null

    val list = listOf(1, 3, 5, 7, 9)
    println(list.min()) //1

### minBy操作符

    根据给定的函数返回最小的一项，如果没有则返回null

    val list = listOf(1, 3, 5, 7, 9)
    println(list.minBy { -it }) //9

### none操作符

    如果没有任何元素与给定的函数匹配，则返回true

    val list = listOf(1, 3, 5, 7, 9)
    println(list.none { it > 10 }) //true

### reduce操作符

    与 fold  一样，但是没有一个初始值。通过一个函数从第一项到最后一项进行累计

    val list = listOf(1, 3, 5, 7, 9)
    println(list.reduce { total, next ->
        println("$next , $total")
        total + next
    })
log日志
    3 , 1
    5 , 4
    7 , 9
    9 , 16
    25

#### reduceRight

    与 reduce  一样，但是顺序是从最后一项到第一项

    val list = listOf(1, 3, 5, 7, 9)
    println(list.reduceRight { next, total ->
        println("$next , $total")
        total + next
    })
log日志
    7 , 9
    5 , 16
    3 , 21
    1 , 24
    25

#### sumBy

    返回所有每一项通过函数转换之后的数据的总和

    val list = listOf(1, 3, 5, 7, 9)
    println(list.sumBy { it + 1 }) //30

 二、过滤操作符

### drop

返回包含去掉前n个元素的所有元素的列表

    val list = listOf(1, 3, 5, 7, 9)
    println(list.drop(2)) //[5, 7, 9]

#### dropWhile

    返回从第一个开始不符合给定函数的元素起之后的列表

    val list = listOf(1, 3, 5, 7, 9, 2)
    println(list.dropWhile { it < 4 }) //[5, 7, 9, 2]

#### dropLastWhile

    从最后一项开始，返回从开始不符合给定函数的元素起之后的列表

  val list = listOf(10, 1, 3, 5, 7, 9)
  println(list.dropLastWhile { it > 4 }) //[10, 1, 3]

#### filter

    过滤所有符合给定函数条件的元素

  val list = listOf(1, 3, 5, 7, 9, 2)
  println(list.filter { it < 4 }) //[1, 3, 2]

#### filterNot

    过滤所有不符合给定函数条件的元素

    val list = listOf(1, 3, 5, 7, 9, 2)
    println(list.filterNot { it < 4 }) //[5, 7, 9]

#### filterNotNull

    过滤所有元素中不是null的元素

    val list = listOf(1, 3, 5, 7, 9, 2, null)
    println(list.filterNotNull()) //[1, 3, 5, 7, 9, 2]

#### slice

    过滤一个list中指定index的元素

    val list = listOf(1, 3, 5, 7, 9, 2, null)
    println(list.slice(listOf(0, 3))) //[1, 7]

#### take

    返回从第一个开始的n个元素

    val list = listOf(1, 3, 5, 7, 9, 2, null)
    println(list.take(2)) //[1, 3]

#### takeLast

    返回从最后一个开始的n个元素

    val list = listOf(1, 3, 5, 7, 9, 2, null)
    println(list.takeLast(2)) //[2, null]

#### takeWhile

    返回从第一个开始符合给定函数条件的元素。

    val list = listOf(1, 3, 5, -1, 7, 9, 2)
    println(list.takeWhile { it > 2 }) //[]
    println(list.takeWhile { it > 0 }) //[1, 3, 5]

三、映射操作符

#### flatMap

    遍历所有的元素，为每一个创建一个集合，最后把所有的集合放在一个集合中

    val list = listOf(1, 3, 5, -1, 7, 9, 2)
    println(list.flatMap { listOf(it, it + 1) }) //[1, 2, 3, 4, 5, 6, -1, 0, 7, 8, 9, 10, 2, 3]

#### groupBy

    返回一个根据给定函数分组后的map 

    val list = listOf(1, 3, 5, -1, 7, 9, 2)
    println(list.groupBy { listOf(it) }) //{[1]=[1], [3]=[3], [5]=[5], [-1]=[-1], [7]=[7], [9]=[9], [2]=[2]}
    println(list.groupBy { listOf(it, it + 1) }) //{[1, 2]=[1], [3, 4]=[3], [5, 6]=[5], [-1, 0]=[-1], [7, 8]=[7], [9, 10]=[9], [2, 3]=[2]}

#### map 

     返回一个每一个元素根据给定的函数转换所组成的List。

    val list = listOf(1, 3, 5, -1, 7, 9, 2)
    println(list.map { listOf(it) }) //[[1], [3], [5], [-1], [7], [9], [2]]
    println(list.map { listOf(it, it + 1) }) //[[1, 2], [3, 4], [5, 6], [-1, 0], [7, 8], [9, 10], [2, 3]]

#### mapIndexed 

    返回一个每一个元素根据给定的包含元素index的函数转换所组成的List

    val list = listOf(1, 3, 5, -1, 7, 9, 2)
    println(list.mapIndexed { index, value -> index }) //[0, 1, 2, 3, 4, 5, 6]
    println(list.mapIndexed { index, value -> index * value }) //[0, 3, 10, -3, 28, 45, 12]

#### mapNotNull 

    返回一个每一个非null元素根据给定的函数转换所组成的List

    val list = listOf(1, 3, 5, -1, 7, 9, null, 2)
    println(list.mapNotNull { it }) //[1, 3, 5, -1, 7, 9, 2]

四、元素操作符 

### contains 

    如果指定元素可以在集合中找到，则返回true

    val list = listOf(1, 3, 5, -1, 7, 9, null, 2)
    println(list.contains(3)) //true
    println(list.contains(13)) //false

### elementAt 

    返回给定index对应的元素，如果index数组越界则会抛出 IndexOutOfBoundsException

    val list = listOf(1, 3, 5, -1, 7, 9, null, 2)
    println(list.elementAt(3)) //-1
    println(list.elementAt(6)) //null

#### elementAtOrElse 

    返回给定index对应的元素，如果index数组越界则会根据给定函数返回默认值

    val list = listOf(1, 3, 5, -1, 7, 9, null, 2)
    println(list.elementAtOrElse(3, { it * 2 }))  //-1
    println(list.elementAtOrElse(16, { it * 2 })) //32

### elementAtOrNull 

    返回给定index对应的元素，如果index数组越界则会返回null

    val list = listOf(1, 3, 5, -1, 7, 9, null, 2)
    println(list.elementAtOrNull(3))  //-1
    println(list.elementAtOrNull(16)) //null

### first 

    返回符合给定函数条件的第一个元素

    val list = listOf(1, 3, 5, -1, 7, 9, 2)
    println(list.first { it % 3 == 0 })  //3

#### firstOrNull 

    返回符合给定函数条件的第一个元素，如果没有符合则返回null

    val list = listOf(1, 3, 5, -1, 7, 9, 2)
    println(list.firstOrNull { it % 3 == 0 })  //3
    println(list.firstOrNull { it % 8 == 0 })  //null

#### indexOf 

    返回指定元素的第一个index，如果不存在，则返回 -1

    val list = listOf(1, 3, 5, -1, 7, 9, 2)
    println(list.indexOf(5))  //2
    println(list.indexOf(12)) //-1

#### indexOfFirst 

    返回第一个符合给定函数条件的元素的index，如果没有符合则返回 -1

    val list = listOf(1, 3, 5, 1, 7, 9, 2)
    println(list.indexOfFirst { it % 2 == 0 })   //6
    println(list.indexOfFirst { it % 12 == 0 })  //-1

#### indexOfLast 

    返回最后一个符合给定函数条件的元素的index，如果没有符合则返回 -1

    val list = listOf(1, 3, 5, 6, 7, 9, 2)
    println(list.indexOfLast { it % 2 == 0 })   //6
    println(list.indexOfLast { it % 12 == 0 })  //-1

#### last 

    返回符合给定函数条件的最后一个元素

    val list = listOf(1, 3, 5, 6, 7, 9, 2)
    println(list.last { it % 2 == 0 })   //2
    println(list.last { it % 3 == 0 })   //9

#### lastIndexOf 

    返回指定元素的最后一个index，如果不存在，则返回 -1

    val list = listOf(1, 3, 2, 6, 7, 9, 2)
    println(list.lastIndexOf(2))    //6
    println(list.lastIndexOf(12))   //-1

#### lastOrNull 

    返回符合给定函数条件的最后一个元素，如果没有符合则返回null

    val list = listOf(1, 3, 2, 6, 7, 9, 2)
    println(list.lastOrNull { it / 3 == 3 })    //9
    println(list.lastOrNull { it == 10 })       //null

#### single 

    返回符合给定函数的单个元素，如果没有符合或者超过一个，则抛出异常

    val list = listOf(1, 9, 2, 6, 7, 9, 2)
    println(list.single { it % 7 == 0 })  //7
    println(list.single { it == 2 })      //IllegalArgumentException

#### singleOrNull 

    返回符合给定函数的单个元素，如果没有符合或者超过一个，则返回null

    val list = listOf(1, 9, 2, 6, 7, 9, 2)
    println(list.singleOrNull { it % 7 == 0 })  //7
    println(list.singleOrNull { it == 2 })      //null

五、生产操作符 

### partition 

    把一个给定的集合分割成两个，第一个集合是由原集合每一项元素匹配给定函数条 件返回 true 的元素组成，第二个集合是由原集合每一项元素匹配给定函数条件返回 false 的元素组成

    val list = listOf(1, 9, 2, 6, 7, 9, 2)
    val (list1, list2) = list.partition { it % 2 == 0 }
    println(list1)  //[2, 6, 2]
    println(list2)  //[1, 9, 7, 9]

### plus 

    返回一个包含原集合和给定集合中所有元素的集合，因为函数的名字原因，我们可以使用 + 操作符

    val list1 = listOf(1, 9, 2, 6, 7, 9, 2)
    val list2 = listOf(1, 2, 4, 6, 8, 10)
    println(list1.plus(list2)) //[1, 9, 2, 6, 7, 9, 2, 1, 2, 4, 6, 8, 10]
    println(list1 + list2)  //[1, 9, 2, 6, 7, 9, 2, 1, 2, 4, 6, 8, 10]

### zip 

    返回由 pair 组成的List，每个 pair 由两个集合中相同index的元素组成。这个返回的List的大小由最小的那个集合决定

    val list1 = listOf(1, 9, 2, 6, 7, 9, 2)
    val list2 = listOf(1, 2, 4, 6, 8, 10)
    val list3 = list1.zip(list2)
    println(list3.javaClass)
    println(list3.get(0).javaClass)
    println("${list3.get(0).first} , ${list3.get(0).second}")
    list3.forEach { println(it) }
log日志
    class java.util.ArrayList
    class kotlin.Pair
    1 , 1
    (1, 1)
    (9, 2)
    (2, 4)
    (6, 6)
    (7, 8)
    (9, 10)

### unzip 

    从包含pair的List中生成包含List的Pair

   val list1 = listOf(Pair("leavesC", 1), Pair("leavesC_2", 2), Pair("leavesC_3", 3))
    val list2 = list1.unzip()
    println(list2.javaClass)
    println(list2.first)
    println(list2.second)
log日志
    class kotlin.Pair
    [leavesC, leavesC_2, leavesC_3]
    [1, 2, 3]

六、顺序操作符 

### reverse 

    返回一个与指定list相反顺序的list

    val list1 = listOf(Pair("leavesC", 1), Pair("leavesC_2", 2), Pair("leavesC_3", 3))
    val list2 = list1.reversed()
    println(list2)      //[(leavesC_3, 3), (leavesC_2, 2), (leavesC, 1)]

### sort 

    返回一个自然排序后的list

    val list1 = listOf(2, 4, 1, 9, 5, 10)
    val list2 = list1.sorted()
    println(list2) //[1, 2, 4, 5, 9, 10]

    val list3 = listOf("a", "c", "ab", "b", "cdd", "cda")
    val list4 = list3.sorted()
    println(list4) //[a, ab, b, c, cda, cdd]

### sortBy 

    返回一个根据指定函数排序后的list 

    val list1 = listOf(2, 4, 1, 9, 5, 10)
    val list2 = list1.sortedBy { it - 3 }
    println(list2) //[1, 2, 4, 5, 9, 10]

### sortDescending 

    返回一个降序排序后的List

    val list1 = listOf(2, 4, 1, 9, 5, 10)
    val list2 = list1.sortedDescending()
    println(list2) //[10, 9, 5, 4, 2, 1]

### sortDescendingBy 

    返回一个根据指定函数降序排序后的list

    val list1 = listOf(2, 4, 1, 9, 5, 10)
    val list2 = list1.sortedByDescending { it % 2 }
    println(list2) //[1, 9, 5, 2, 4, 10]

 

huydl
关注
专栏目录
Kotlin学习笔记（六）：Kotlin中常见的操作符
LrvingTc的博客
02-06 3544
一、元素操作符 contains:判断是否有指定元素。 elementAt:返回对应的元素，越界会抛IndexOutOfBoundsException。 firstOrNull:返回符合条件的第一个元素，没有返回null。 lastOrNull:返回符合条件的最后一个元素，没有返回null。 indexOf:返回指定元素的下标，没有返回-1。 二、判断类 any:判断集合中是否有满足条件的元...
Kotlin 高阶函数
SophieBryant的博客
03-27 313
官方api其实已经将我们常用的快捷操作用高阶函数给封装好了，比如with,apply等操作符，所以剩下的就是接口调用了。 不知道大家用Kotlin实现过OnClickListener接口没有，有3种写法： 普通点击: view.setOnClickListener(object:View.OnClickListener{overridefunonClick(...
Kotlin 操作符：run、with、let、also、apply 的差异与选择
星辰旋风的博客
11-22 673
转自原文链接 Kotlin 操作符：run、with、let、also、apply 的差异与选择 Kotlin 操作符：run、with、let、also、apply 的差异与选择 Kotlin 的一些操作符非常相似，我们有时会不确定使用哪种功能。在这里我将介绍一个简单的方法来清楚地区分他们的差异，最后以及如何选择使用。 首先我们以下这个代码： class MyClass { ...
Kotlin系列之常用操作符
Young
06-21 4890
前言：本篇文章来介绍下Kotlin的常用操作符。kotlin相对于java来说是一门十分简洁的语言，这其中操作符起了很大的作用，这些操作符和Rxjava的十分类似，如果你十分熟悉Rxjava，那么这些操作符学起来就得心应手很多，毕竟这些操作符还是挺简单的说。。。常用操作符大致可以分为 总数操作符 过滤操作符 映射操作符 元素操作符 生产操作符 顺序操作符 首先我想说的是，学习这些操作符应该从以下几个
Kotlin中常用操作符和用法介绍
热门推荐
俊光的专栏
07-19 1万+
Kotlin中出现的常用操作符和用法介绍 ？操作符 表示这个对象可能为空 //在变量类型后面加上问号，代表该变量是可空变量 var name: String? = "zhangsan" /** * 如果str不能转为Int类型，则返回null */ fun parseInt(str: String): Int? { // (代码略) } b?.length //
kotlin操作符
最新发布
2401_84415615的博客
05-15 842
代码真的是重质不重量，质量高的代码，是当前代码界提倡的，当然写出高质量的代码肯定需要一个相当高的专业素养，这需要在日常的代码书写中逐渐去吸收掌握，谁不是每天都在学习呀，目的还不是为了一个，为实现某个功能写出高质量的代码。所以，长征路还长，大家还是好好地做个务实的程序员吧。最后，小编这里有一系列Android提升学习资料，有兴趣的小伙伴们可以来看下哦~《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》点击传送门，即可获取！
Kotlin新手基础学习之Elvis操作符
01-20
Kotlin的语法简洁明了，支持诸如高阶函数、操作符重载和字符串模板等高级特性。与Java不同，Kotlin中没有基本数据类型，所有的数据都被视为对象，如Int、Float和Double等。函数也被视为对象，可以作为参数和返回值，...
Kotlin教程（八）高阶函数
Hubert的博客
04-24 911
写在开头：本人打算开始写一个Kotlin系列的教程，一是使自己记忆和理解的更加深刻，二是可以分享给同样想学习Kotlin的同学。系列文章的知识点会以《Kotlin实战》这本书中顺序编写，在将书中知识点展示出来同时，我也会添加对应的Java代码用于对比学习和更好的理解。 Kotlin教程（一）基础 Kotlin教程（二）函数 Kotlin教程（三）类、对象和接口 Kotlin教程（四）可空...
【Android】聊聊Kotlin操作符重载
m0_64365896的博客
02-16 337
不过kotlin-stblib库已经帮你实现好了关于集合的类似操作. 在集合中+,-会累加集合原始后返回一个新的集合，如果使用+=,-=, 集合是mutable，会在本集合直接修改内容，如果集合是read-only,会返回一个拷贝后的修改集合。（这意味着如果集合是read-only，它的声明必须要是var, 不然它不能接受新返回拷贝后的修改集合）. 你可以使用单独的元素或者集合（类型必须一致）进行复合运算符操作和算数运算符.请注意，在 Kotlin 中，它也是一种约定，这意味着可以将迭代器方法定义为扩展。
Kotlin 面试题汇总
u010603363的博客
11-20 944
在kotlin 中，int, double,float 这些类型是没有的，在kotlin 中需要使用 Int，这是引用类型，以及Double,Float 这些类型。您可以使用$符号来使用字符串中的某些变量，也可以在{}符号之间执行一些操作。就是定义一个变量，然后当用户获取时，如果变量值为空，那么就会包未初始化异常，如果用户后面进行了初始化，就直接返回了这个值。因此，要将空值分配给变量，您需要将name变量声明为可空字符串，然后在访问此变量期间，您需要使用安全调用运算符，即?
Kotlin操作符
提辖鲁的博客
08-02 1288
优先级 说明 符号 最高 后缀（Postfix ） ++, --, ., ?., ? 前缀（Prefix） -, +, ++, --, !, labelDefinition@ 右手类型运算（Type RHS，right-hand side class type (RHS) ） :, as, as? 乘除取余（Mu...
Kotlin之操作符
七夜聖君的博客
12-28 373
Kotlin之常用操作符
kotlin操作符(1)
2401_84149220的博客
04-18 1013
元素操作符生产操作符顺序操作符首先我想说的是，学习这些操作符应该从以下几个方面进行敲：在开发工具里面敲这些代码看：点击去看看操作符的源码跑：亲自跑一下代码，看看运行的结果思：综合思考这些操作符的意义，加深理解总数操作符//any 只要有一个符合就返回true//all 所有条件符合才返回true//count 返回符合条件的数目//none 如果没有任何元素与给定的函数匹配，则返回true。
Kotlin中的操作符函数
AirField的博客
02-28 1349
Kotlin 中的操作符函数 这节课我们来聊聊 Kotlin 这门语言对函数式编程的支持。我们都知道在 Kotlin 这门语言中函数荣升成为了一等公民，所以在支持函数式编程的方面，Kotlin 也是非常给力的，并且在 Kotlin 中语法也尽量推荐接近函数式编程的风格。 学过以及了解过函数式编程的小伙伴都知道函数式编程最吸引人的地方，莫过于它拥有丰富的函数式操作符，可以使用一种全新的编程方式去操作集合数据。其中操作符最流行莫过于函数式中“三板斧”(过滤filter、映射map、折叠foldLeft/化约
Kotlin(1)-lambda表达式和高阶函数操作符
目标检测专栏持续更新中，改进YOLO系列通用，适用v5、v7、v8、所有博客均是团队原创博客，所有文章禁止转载，违者必究。
06-13 1294
前言 以一个java老鸟的角度，如何去看 kotlin。 Java源代码应该如何用Kotlin重构。 如何正确学习kotlin并且应用到实际开发中。本文将会探究。 本文分两大块，重难点和潜规则。 重难点：Kotlin中可以独立出来讲解的大块知识点。提供单独Demo。这部分大多数是Kotlin开创的新概念（相比于Java）。 潜规则：Kotlin是谷歌用来替换Java的，它和java百分百完全兼容，但是实际上java转成kotlin之后，需要我们手动修改很多东西，甚至某些部分必须打散重构来达到最优编码。其中，
Kotlin基本操作符
zhujie_的博客
12-08 180
class SecondActivity : AppCompatActivity() { var context: Context? = this; override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main); for(i in 1..10 ste
kotlin常用操作符
m0_37550680的博客
06-15 331
最近因为谷歌在IO大会上宣布Kotlin为Android第一开发语言之后，Kotlin着实火了一把，甚至有人预言，Kotlin将在不久之后完全取代Java对于Android的作用，我闲着无事，整合了一下kotlin的常用操作符，对于初学者来说会有很大帮助。     1.安全转换操作符：as       例： CompanyBean mCompany = intent.getS
Kotlin 操作符学习
senkai123的博客
01-05 347
今天是2021年的第5天，终于有时间来写自己的博客了和学习新的知识点，希望自己在新的的一年有收获，我要给自己立个flag，每天今天发布一篇关于Kotlin 的知识，后期项目开发准备用它了，从Java混合，到全部Kotlin Kotlin 操作符 在学习Kotlin之前最好有对比Java思想来学习，我也知识挑常用的操作符来记录 在Kotlin 中声明一个变量的时候，可以这样 //声明 var name：String=“” name=null //编译报错 如何使其编译通过，就要用到 ？操作符，直接声明到
kotlin-常用操作符
u012693479的博客
06-05 477
1：Elvis操作符 如果 ?: 左边表达式非空，elvis操作符就会返回左边的结果，否则返回右边的结果。 请注意，仅在左侧为空的时候，右侧的表达式才会计算。 fun elvisTest(b: String?) { val a= b?.length ?: -1 // 等价于 val a:Int = if( b!= null) b.length else -1 Log.d("alen","b is${b}" + ",a is " +a) } 2：类型转换as和安全转换 as...
Kotlin编程指南：从基础到高级
4. **高阶函数和Lambda表达式**：高阶函数可以接收其他函数作为参数或返回一个函数。Lambda表达式提供了简洁的匿名函数定义，使得函数式编程风格更加流畅。 5. **协程**：Kotlin的协程设计用于解决异步编程的问题，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值