Kotlin集合操作符

2023-07-04  本文已影响0人  Android出海

集合是开发中非常常用的知识，比如操作各种数据集，各种算法，保存网络请求结果等，如果你不会集合的知识，那么可能连显示一个基本的ListView列表都做不到，今天就来说说Kotlin中集合的知识。
Kotlin中集合操作符大致可分为6大类，分别是：

注意：在Kotlin中数组和list的操作符基本共同，所以在数组中可用的操作符也可以在list中使用。

统计操作符

    val array = arrayOf(1, 2, 3, 4, 5, 6, 7)
    println("any,数组中有值等于7，${array.any { it == 7 }}")
    println("all,数组中是否所有值都大于3，${array.all { it > 3 }}")
    println("count,数组中大于5的值有几个，${array.count { it > 5 }}")
    println("none,数组中没有大于9的数，${array.none { it > 9 }}")
    println("max,数组中的最大值，${array.max()}")
    println("min,数组中的最小值，${array.min()}")
    println("fold操作符的例子，${array.fold(4) { returnValue, next -> returnValue + next }}")
    //相对于fold操作符，相当于返回值的初始值为0
    println("reduce操作符的例子，${array.reduce { returnValue, next -> returnValue + next }}")
    println("sum,求数组中所有值的总和(也可以用 fold和reduce操作实现)，${array.sum()}")

any,数组中有值等于7，true
all,数组中是否所有值都大于3，false
count,数组中大于5的值有几个，2
none,数组中没有大于9的数，true
max,数组中的最大值，7
min,数组中的最小值，1
fold操作符的例子，32
reduce操作符的例子，28
sum,求数组中所有值的总和(也可以用 fold和reduce操作实现)，28

元素操作符

val array = arrayOf(1, 2, 3, 4, 5, 6, 7)
println("contains,数组中是否包含值为5的元素，${array.contains(5)}")
println("first,返回第一个满足给定条件的元素,大于3的条件，${array.first { it > 3 }}")
println("last,返回最后一个满足给定条件的元素，大于5的条件，${array.last { it > 5 }}")
println("indexOf,返回值为3在数组中的下标值，${array.indexOf(3)}")
println("elementAt,返回数组中下标为2的值，${array.elementAt(2)}")
println("single,返回数组中的满足条件的一个元素，如果没有或者满足条件的有多个就抛出异常，${array.single{it >6}}")
println("find,数组中的元素值，${array.find { it==7 }}")

contains,数组中是否包含值为5的元素，true
first,返回第一个满足给定条件的元素,大于3的条件，4
last,返回最后一个满足给定条件的元素，大于5的条件，7
indexOf,返回值为3在数组中的下标值，2
elementAt,返回数组中下标为2的值，3
single,返回数组中的满足条件的一个元素，如果没有或者满足条件的有多个就抛出异常，7
find,数组中的元素值，7

顺序操作符

fun <T> Array<T>.toStringExt(): String {
    val sb = StringBuilder("[")
    for ((index, value) in this.withIndex()) {
        sb.append(value)
        sb.append(",")
    }
    sb.delete(sb.length - 1, sb.length)
    sb.append("]")
    return sb.toString()
}

 data class Person(val age: Int, val weight: Int, val name: String) {
        override fun toString(): String {
            return "{$age,$weight,${name}}"
        }
}

fun main() {
    val array = arrayOf(1, 2, 5, 4, 3, 6, 7)
    println("reversed，返回一个具有相反顺序的数组，${array.reversed()}")
    println("shuffled，返回一个随机顺序的数组，${array.toList().shuffled()}")
    println("sorted，返回一个升序的排序的数组，${array.sorted()}")
    println("sortedDescending，返回一个降序排序的数组，${array.sortedByDescending { it }}")
    val persons = arrayOf(
            Person(18, 45, "小红"),
            Person(16, 50, "小绿"),
            Person(22, 48, "小紫"),
            Person(18, 50, "小蓝")
        )
    persons.sortBy { it.age }
    println("sortedBy，根据指定的值进行升序排序，${persons.toStringExt()}")
    persons.sortByDescending { it.weight }
    println("sortByDescending，根据指定的值进行降序排序，${persons.toStringExt()}")
}

reversed，返回一个具有相反顺序的数组，[7, 6, 3, 4, 5, 2, 1]
shuffled，返回一个随机顺序的数组，[4, 7, 1, 6, 3, 2, 5]
sorted，返回一个升序的排序的数组，[1, 2, 3, 4, 5, 6, 7]
sortedDescending，返回一个降序排序的数组，[7, 6, 5, 4, 3, 2, 1]
sortedBy，根据指定的值进行升序排序，[{16,50,小绿},{18,45,小红},{18,50,小蓝},{22,48,小紫}]
sortByDescending，根据指定的值进行降序排序，[{16,50,小绿},{18,50,小蓝},{22,48,小紫},{18,45,小红}]

映射操作符

 val array = arrayOf(1, 2, 5, 4, 3, 6, 7)
    println("map1: ${array.map { it % 2 == 0 }}")
    println("map2: ${array.map { it + 3 }}")
    println("slice: ${array.slice(1..5)}")
    println("slice: ${array.slice(listOf(1, 3, 0))}")
    println("chunked: ${array.toList().chunked(3)}")
    val array1 = mutableListOf(mutableListOf(1, 5, 9),mutableListOf(11, 40, 21), mutableListOf(3, 15, 10), mutableListOf(6, 8, 10))
    println("array1 = $array1")
    //平铺array1中的数据 并过滤掉 大于等于10的数据
    println("flatMap: ${array1.flatMap { it -> it.filter { it < 10 } }}")
    println("flatten: ${array1.flatten()}")
    val persons = arrayOf(Person(16,45,"小红"),Person(16,50,"小绿"),Person(18,45,"小紫"),Person(18,50,"小蓝"))
    println("groupBy_age: ${persons.groupBy{it.age}}")
    println("groupBy_weight: ${persons.groupBy{it.weight}}")

map1: [false, true, false, true, false, true, false]
map2: [4, 5, 8, 7, 6, 9, 10]
slice: [2, 5, 4, 3, 6]
slice: [2, 4, 1]
chunked: [[1, 2, 5], [4, 3, 6], [7]]
array1 = [[1, 5, 9], [11, 40, 21], [3, 15, 10], [6, 8, 10]]
flatMap: [1, 5, 9, 3, 6, 8]
flatten: [1, 5, 9, 11, 40, 21, 3, 15, 10, 6, 8, 10]
groupBy_age: {16=[{16,45,小红}, {16,50,小绿}], 18=[{18,45,小紫}, {18,50,小蓝}]}
groupBy_weight: {45=[{16,45,小红}, {18,45,小紫}], 50=[{16,50,小绿}, {18,50,小蓝}]}

过滤操作符

 val array = arrayOf(1, 2, 5, 4, 3, 6, 7)
    println("filter：${array.filter { it < 7 }}")
    println("take：${array.take(5)}")
    println("take：${array.take(10)}")
    println("drop：${array.drop(3)}")

filter：[1, 2, 5, 4, 3, 6]
take：[1, 2, 5, 4, 3]
take：[1, 2, 5, 4, 3, 6, 7]
drop：[4, 3, 6, 7]

生成操作符

data class Day(val day: Int, val name: String) {
        override fun toString(): String {
            return "{$day,${name}}"
        }
    }

fun <T> Array<T>.toStringExt(): String {
    val sb = StringBuilder("[")
    for ((index, value) in this.withIndex()) {
        sb.append(value)
        sb.append(",")
    }
    sb.delete(sb.length - 1, sb.length)
    sb.append("]")
    return sb.toString()
}

fun main() {
    val array = arrayOf(1, 2, 5, 4, 3, 6, 7)
    println("array：${array.toStringExt()}")
    println("plus：${array.plus(19).toStringExt()}")
    println("partition：${array.partition { it < 5 }}")
    val array1 = arrayOf("今天", "明天", "后天", "天天都爱你")
    println("zip1：${array.zip(array1)}")
    println("zip2：${array.zip(array1) { a, b -> Day(a,b) }}")  
}

array：[1,2,5,4,3,6,7]
plus：[1,2,5,4,3,6,7,19]
partition：([1, 2, 4, 3], [5, 6, 7])
zip1：[(1, 今天), (2, 明天), (5, 后天), (4, 天天都爱你)]
zip2：[Day ={1,今天}, Day ={2,明天}, Day ={5,后天}, Day ={4,天天都爱你}]

上一篇 下一篇

猜你喜欢

热点阅读