kotlin集合操作符初探_kotlin sorteddescending

在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()}")
1
2
3
4
5
6
7
8
9
10
11

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}}")
1
2
3
4
5
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()}")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

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)}}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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)}")
1
2
3
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()}")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

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]