在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]
