kotlin集合操作符初探

原创
09/30 16:31
阅读数 2.8K

在kotlin中数组和list的操作符基本共同,所以在数组中可用的操作符也可以在list中使用。

统计操作符

  • any 只要有一个符合就返回true
  • all 所有条件符合才返回true
  • count 返回符合条件的数目
  • none 如果没有任何元素与给定的函数匹配,则返回true
  • max 返回最大值
  • min 返回最小值
  • fold 在一个初始值的基础上 从第一项到最后一项通过 一个函数操作 所有的元素
  • reduce 从第一项到最后一项通过 一个函数操作 所有的元素,相对于fold,没有初始值
  • sum 求数组中所有值的和
 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

元素操作符

  • contains,数组中是否包含某个元素
  • first,返回第一个满足给定条件的元素
  • last,返回最后一个满足给定条件的元素
  • indexOf,返回某个值在数组中的下标值
  • elementAt,返回数组中某个下标的值
  • single,返回数组中的满足条件的一个元素,如果没有或者满足条件的有多个就抛出异常
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}}")

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

顺序操作符

  • reversed,返回一个具有相反顺序的数组
  • sorted,返回一个升序的排序的数组
  • sortedDescending,返回一个降序排序的数组
  • sortedBy,根据指定的值进行升序排序
  • sortedByDescending,根据指定的值进行降序排序
fun <T> Array<T>.toString1(): 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){
    override fun toString(): String {
        return "{$age,$weight}"
    }
}
fun main() {
    val array = arrayOf(1, 2, 5, 4, 3, 6, 7)
    println("reversed,返回一个具有相反顺序的数组${array.reversed()}")
    println("sorted,返回一个升序的排序的数组,${array.sorted()}")
    println("sortedDescending,返回一个降序排序的数组${array.sortDescending()}")
    val persons = arrayOf(Person(18, 45), Person(16, 50), Person(22, 48))
    persons.sortBy { it.age }
    println("sortedBy,根据指定的值进行升序排序,${persons.toString1()}")
    persons.sortByDescending { it.weight }
    println("sortedByDescending,根据指定的值进行降序排序,${persons.toString1()}")
}

reversed,返回一个具有相反顺序的数组[7, 6, 3, 4, 5, 2, 1] sorted,返回一个升序的排序的数组,[1, 2, 3, 4, 5, 6, 7] sortedDescending,返回一个降序排序的数组kotlin.Unit sortedBy,根据指定的值进行升序排序,[{16,50},{18,45},{22,48}] sortedByDescending,根据指定的值进行降序排序,[{16,50},{22,48},{18,45}]

映射操作符

  • map,返回一个列表,其中包含将给定 函数 应用于原始数组中每个元素的结果.
  • flatMap,返回在原始数组的每个元素上调用 函数 的结果,所产生的所有元素的单个列表。(flatMap的传入函数的返回必须是可迭代的 Iterable),flatMap的主要主要就是把多层的集合平铺成一层的。
  • flatten,返回给定集合中所有集合的所有元素的单个列表,相当于flatmap中的函数不对元素进行任何操作
  • groupBy 按照给定的元素进行分组,返回的是一个map
 val array = arrayOf(1, 2, 5, 4, 3, 6, 7)
    println("map1: ${array.map { it % 2 == 0 }}")
    println("map2: ${array.map { it + 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}}")

    //通过应用到元素*的给定[keySelector]函数返回的键,将应用于原始数组*的[valueTransform]函数返回的值分组,
    // 并返回一个映射,其中每个组键与对应值列表相关联。 * *返回的映射保留了从原始数组产生的键的条目迭代顺序。
    println("groupBy 按年龄分组,并修改年龄分组中的实体类 == ${persons.groupBy({it.age}){Student(it.age,it.weight,(9..12).random(),it.name)}}")

map1: [false, true, false, true, false, true, false] map2: [4, 5, 8, 7, 6, 9, 10] 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,小蓝}]} groupBy 按年龄分组,并修改年龄分组中的实体类 == {16=[{学生:小红,年级:9,年龄:16,体重:45}, {学生:小绿,年级:9,年龄:16,体重:50}], 18=[{学生:小紫,年级:11,年龄:18,体重:45}, {学生:小蓝,年级:12,年龄:18,体重:50}]}

过滤操作符

  • filter,返回数组中符合给定条件的元素列表
  • take,返回包含前[n]个元素的列表,(入参就是n值)
  • drop,返回包含除前[n]个元素外的所有元素的列表
 val array = arrayOf(1, 2, 5, 4, 3, 6, 7)
    println("filter:${array.filter { it < 5 }}")
    println("take:${array.take(4)}")
    println("drop:${array.drop(4)}")

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

生成操作符

  • zip,将两个数组进行和并,返回一个Pair的list ,pair中包含有两个数组中相同下标的元素,返回的list的长度,由最短的数组决定。(也可以自定义返回列表中的类型)
  • partition,返回一个Pair 其中包含两个列表,第一个列表时符合给定条件的列表,第二个列表时不合符条件的列表。(类似于filter ,只是把过来后的元素组成了一个列表一起返回了)
  • plus,返回一个在原数组的基础上,追加了一个新元素的新数组。原数组没有改变
data class Person(val age: Int, val name: String) {
    override fun toString(): String {
        return "{$age,$name}"
    }
}

fun <T> Array<T>.toString1(): 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)
    val array1 = arrayOf("今天", "明天", "后天", "天天都爱你")
    println("zip1:${array.zip(array1)}")
    println("zip2:${array.zip(array1) { a, b -> Person(a,b) }}")
    println("partition:${array.partition { it < 5 }}")
    println("plus:${array.plus(19).toString1()}")
    println("array:${array.toString1()}")
}

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

展开阅读全文
打赏
1
2 收藏
分享
加载中
更多评论
打赏
0 评论
2 收藏
1
分享
返回顶部
顶部