Kotlin的那些List相关的操作符

1.all

判断list中所有的元素的限定条件，如果全部满足则返回true

val list = listOf<Int>(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
var all = list.all { it >= 0 }
println("all ->  $all") 
//打印 all ->  true
all = list.all { it >10}
println("all -> $all")
//打印 all -> false

2.any

判断list中所有的元素的限定条件，如果有至少一个满足则返回true

val list = listOf<Int>(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
var any = list.any { it > 8 }
println("any -> $any")
//打印 any -> true
any = list.any { it>10 }
println("any -> $any")
//打印 any -> false

3.count

获取数组中满足条件的元素个数

val list = listOf<Int>(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
var count = list.count { it > 2 }
println("count -> $count")
//打印 count -> 7
count = list.count { it < 5 }
println("count -> $count")
//打印 count -> 5

4.none

判断数组中所有元素的限定条件，如果全部都不满足则返回true，和all相对

val list = listOf<Int>(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
var none = list.none { it > 5 }
//打印 none -> false
println("none -> $none")
none = list.none { it > 10 }
println("none -> $none")
//打印 none -> true

5.fold

这是一个对数组内所有元素进行一定算法计算的方法，返回最终计算出的结果

public inline fun <T, R> Iterable<T>.fold(initial: R, operation: (acc: R, T) -> R): R {
    var accumulator = initial
    for (element in this) accumulator = operation(accumulator, element)
    return accumulator
}

可以看出，这里会传入一个初始的值，并赋值局部变量，依次遍历数组中的元素，根据这个初始值和此时的元素进行一定算法后，再赋值给这个局部变量，一直到遍历完毕，最终返回和初始值相同类型的值。
类似于我们常用的 result = result + item的方式

val list = listOf<Int>(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
val fold1 = list.fold("start", { result, item -> "$result-$item" })
val fold2 = list.fold(2) { result, item -> result + item }
println("fold1 -> $fold1  ")
//打印 fold1 -> start-0-1-2-3-4-5-6-7-8-9 
println("fold2 -> $fold2  ")
//打印 fold2 -> 47  

6.foldRight

对数组进行倒叙遍历，根据一定算法计算出最终的结果

public inline fun <T, R> List<T>.foldRight(initial: R, operation: (T, acc: R) -> R): R {
    var accumulator = initial
    if (!isEmpty()) {
        val iterator = listIterator(size)
        while (iterator.hasPrevious()) {
            accumulator = operation(iterator.previous(), accumulator)
        }
    }
    return accumulator
}

可以看出和fold类似，只是foldRight方法是倒叙的，并且计算赋值的参数是在第二个。

val list = listOf<Int>(0, 1, 2, 3)
val fold = list.foldRight("start", { item, result ->
      println("$item   ->>   $result"  )
      "$result-$item" })
println("fold -> $fold")
//输出结果是 
3   ->>   start
2   ->>   start-3
1   ->>   start-3-2
0   ->>   start-3-2-1
fold -> start-3-2-1-0

注意我这里把的item和result和上面fold方法交换了顺序，因为这里的方法的第一个是数组中的元素，第二个是每次计算后的结果

7.reduce

和fold的方法类似，只是这个是没有初始值设置的，会以元素的第一个为具体类型，计算之后返回的类型和第一个元素类型相同，如果数组指定了Int的类型，那么计算的最终结果就一定是Int类型的，如果你计算方法指定计算转成字符串则会编译出错

val list = listOf<Any>(0, 1, 2, 3)
val reduce = list.reduce { result, item -> "$result-$item" }
println("reduce -> $reduce")
//打印  reduce -> 0-1-2-3

8.forEach

遍历数组中的各个元素，用法和Java中的类似

val list = listOf<Int>(0, 1, 2, 3)
list.forEach {
     println("foreach -> $it")
 }
//打印结果
foreach -> 0
foreach -> 1
foreach -> 2
foreach -> 3

9.forEachIndexed

和forEach用法相同，只是这个方法能获取到当前遍历的子item的索引位置

val list = listOf<Int>( 5, 6, 7, 8, 9)
list.forEachIndexed { index, item ->
   println("forEachIndexed -> $index : $item")
}
//打印结果
forEachIndexed -> 0 : 5
forEachIndexed -> 1 : 6
forEachIndexed -> 2 : 7
forEachIndexed -> 3 : 8
forEachIndexed -> 4 : 9

10.max, min

查找到数组中最大/最小的值。不仅仅可以查找Int,字符串也是可以的。

val list = listOf<Int>(0, 1, 2, 3)
val max = list.max()
val min = list.min()
println("max min -> $max $min")
//打印 max min -> 3 0

val list= listOf<String>("A", "B", "C", "D")
......
//打印 max min -> D A

11.maxBy, minBy

对于给定的list集合，根据函数条件去查找出最大/最小的值。也就是会比较函数计算出的值，根据这个值去进行排序，和Java中的compare比较类似

val list = listOf<String>("third", "first", "second")
    fun find(value: String): Int {
        when (value) {
            "first" -> return 1
            "second" -> return 2
            "third" -> return 3
        }
        return -1;
    }
   
val maxBy = list.maxBy { find(it) }
val minBy = list.minBy { find(it) }
println("maxBy minBy -> $maxBy $minBy")
//打印  maxBy minBy -> third first    

这里最终会根据函数的返回值，也就是1，2，3进行大小判断

12.sumBy

对列表中每一项进行操作，然计算出所有子项的和，这个返回值是Int。也就是不论数组中是什么元素，sumBy操作返回的值必须是Int

val list8 = listOf<String>("0", "1", "2", "3")
val sumBy = list8.sumBy { it.toInt() + 1 }
println("sumBy -> $sumBy")
//打印  sumBy -> 10

13.drop

去除集合中前几个元素，返回去除后的一个新的集合

val list = listOf<Int>(0, 1, 2, 3, 4, 5)
val drop = list.drop(2)
println("drop -> $drop  ${list == drop}")
//打印 drop -> [2, 3, 4, 5]  false

14.dropWhile

去除集合中前几个满足条件的元素，返回新的集合，注意是前几个

val list = listOf<Int>(0, 1, 2, 3, 4, 5, 4, 3)
val dropWhile = list.dropWhile { it < 4 }
println("dropwhile -> $dropWhile  ${list ==dropWhile}")
//打印  dropwhile -> [4, 5, 4, 3]  false

15.dropLastWhile

从最后一位开始，去除集合中满足条件的元素，返回新的集合

val list = listOf<Int>(0, 1, 2, 3, 4, 5, 4, 3)
val dropLastWhile = list.dropLastWhile { it < 5 }
println("droplastwhile -> $dropLastWhile")
//打印  droplastwhile -> [0, 1, 2, 3, 4, 5]

16.filter

筛选出集合中满足条件的元素，返回新的集合

val list = listOf<Int>(0, 1, 2, 3, 4, 5, 4, 3)
val filter = list.filter { it > 3 }
println("filter -> $filter")
//打印 filter -> [4, 5, 4]

17.filterNot

和filter相反，是筛选出所有不满足条件的

val list = listOf<Int>(0, 1, 2, 3, 4, 5, 4, 3)
val filter = list.filterNot { it > 3 }
println("filterNot -> $filter")
//打印 filterNot -> [0, 1, 2, 3, 3]

18.filterNotNull

筛选出数组中不为空的元素，返回一个新的集合

val list = listOf<Any?>(1,2,"A",null,"B",3)
val filterNotNull = list.filterNotNull()
println("filterNotNull -> $filterNotNull")
//打印 filterNotNull -> [1, 2, A, B, 3]

19.slice

截取集合中指定区间的元素，这个是闭区间截取，也就是首位和最后一位都会算入

val list = listOf<Int>(0, 1, 2, 3, 4, 5, 4, 3)
val slice1 = list.slice(1..3)
println("slice -> $slice")
//打印 slice -> [1, 2, 3]

除了筛选指定区间，也可以筛选指定位置的元素

val list = listOf<Int>(0, 1, 2, 3, 4, 5, 4, 3)
val slice = list.slice(listOf(1, 3, 6))
println("slice ->$slice")
//打印 slice ->[1, 3, 4]

这个是截取相应索引位置的所有的元素

20.take

取出集合中的前N个元素，组成一个新的集合，和drop相对，drop是去除元素，take是取出元素

val list = listOf<Int>(0, 1, 2, 3, 4, 5, 4, 3, 2, 1)
val take = list.take(5)
println("take -> $take")
//打印 take -> [0, 1, 2, 3, 4]

21.takeLast

取出集合中最后几个元素，组成一个新的集合

val list = listOf<Int>(0, 1, 2, 3, 4, 5, 4, 3, 2, 1)
val take = list.takeLast(5)
println("takeLast -> $take")
//打印 takeLast -> [5, 4, 3, 2, 1]

22.takeWhile

从集合中第一个位置开始，取出满足条件的元素，直到有不满足的元素为止，和filter不同的是这个是取从初始位置开始满足条件的，有不满足条件的就终止，而filter则是取的是全部满足条件的

val list = listOf<Int>(0, 1, 2, 3, 4, 5, 4, 3, 2, 1)
val take = list.takeWhile(5)
println("takeWhile-> $take")
//打印 takeWhile -> [0, 1, 2, 3, 4]

23.map

map和Rxjava的用法类似，是一种类型转换。对集合中每一项进行操作，然后根据每一项操作后的返回值组成一个新的集合

public inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R> {
    return mapTo(ArrayList<R>(collectionSizeOrDefault(10)), transform)
}

public inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.mapTo(destination: C, transform: (T) -> R): C {
    for (item in this)
        destination.add(transform(item))
    return destination
}

可以看出map方法只是用一个新的集合装载transform之后的元素

val list = listOf<Int>(0, 1, 2, 3, 4, 5)
val map = list.map { it >= 5 }
println("map -> $map")
//打印 map -> [false, false, false, false, false, true]
val map2 = list.map { "No.$it" }
println("map -> $map2")
//打印 map -> [No.0, No.1, No.2, No.3, No.4, No.5]

24.flatMap

public inline fun <T, R> Iterable<T>.flatMap(transform: (T) -> Iterable<R>): List<R> {
    return flatMapTo(ArrayList<R>(), transform)
}

public inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapTo(destination: C, transform: (T) -> Iterable<R>): C {
    for (element in this) {
        val list = transform(element)
        destination.addAll(list)
    }
    return destination
}

可以看出flatMap的transform需要返回一个实现Iterable接口的对象，然后把所有的计算结果添加到一个集合中。而Iterable一般是 Collection相关的集合，比如List和Set，所以这个方法相当于对一个元素进行处理后扩充成一个集合，然后所有元素处理的集合叠加成一个最终的大集合

val list = listOf<Int>(0, 1, 2, 3, 4, 5)
val flatmap = list.flatMap {
        listOf("No.$it", "Id.$it")
 }
println("flatMap -> $flatmap")
//打印 flatMap -> [No.0, Id.0, No.1, Id.1, No.2, Id.2, No.3, Id.3, No.4, Id.4, No.5, Id.5]
val flatmap2 = list.flatMap {
       setOf<Int>(it * 2)
 }
println("flatMap -> $flatmap")
//打印 flatMap -> [0, 2, 4, 6, 8, 10]

25.groupBy

这个方法是把集合按照一定的条件进行分组，返回一个分组后的Map，其中Map的Value是分组的子Lis的t集合

public inline fun <T, K> Iterable<T>.groupBy(keySelector: (T) -> K): Map<K, List<T>> {
    return groupByTo(LinkedHashMap<K, MutableList<T>>(), keySelector)
}

public inline fun <T, K, M : MutableMap<in K, MutableList<T>>> Iterable<T>.groupByTo(destination: M, keySelector: (T) -> K): M {
    for (element in this) {
        val key = keySelector(element)
        val list = destination.getOrPut(key) { ArrayList<T>() }
        list.add(element)
    }
    return destination
}

public inline fun <K, V> MutableMap<K, V>.getOrPut(key: K, defaultValue: () -> V): V {
    val value = get(key)
    return if (value == null) {
        val answer = defaultValue()
        put(key, answer)
        answer
    } else {
        value
    }
}

可以看出默认会创建一个LinkedHashMap，然后其中的Value指定为MutableList。然后遍历整个集合的元素，根据自定义方法返回Key进行分组，相同的Key的元素放到同一个集合中

val list = listOf<Int>(0, 1, 2, 3, 4, 5)
val groupBy = list.groupBy { item ->
		when (item % 3) {
            0 -> "组一"
            1 -> "组二"
            2 -> "组三"
            else -> "unKnown"
        }
 }
println("groupBy -> $groupBy")
//打印  groupBy -> {组一=[0, 3], 组二=[1, 4], 组三=[2, 5]}

26.mapIndexed

和.forEachIndexed类似，这个也会返回所有元素的索引以及元素的值，但这个会对所有元素进行处理后返回一个新的集合，返回集合的元素类型以方法处理后返回的为准

val list = listOf<Int>(0, 1, 2, 3, 4, 5)
val mapIndexed = list.mapIndexed { index, item -> "$index:${item * 2}" }
println("mapIndexed -> $mapIndexed")
//打印 mapIndexed -> [0:0, 1:2, 2:4, 3:6, 4:8, 5:10]    

27.mapNotNull

public inline fun <T, R : Any> Iterable<T>.mapNotNull(transform: (T) -> R?): List<R> {
    return mapNotNullTo(ArrayList<R>(), transform)
}

public inline fun <T, R : Any, C : MutableCollection<in R>> Iterable<T>.mapNotNullTo(destination: C, transform: (T) -> R?): C {
    forEach { element -> transform(element)?.let { destination.add(it) } }
    return destination
}

可以看出，返回的是计算出的结果不为null的元素的集合

val list = listOf<Any?>(1, 2, "A", null, "B")
val mapNotNull = list .mapNotNull {if(it ==2 || it ==null) null else "Map->$it"}
println("mapNotNull -> $mapNotNull")
//打印 mapNotNull-> [Map->1, Map->A, Map->B]

28.contains

判断集合是否包含某一个元素

val list = listOf<Any?>(1, 2, "A", null, "B")
val contains = list8.contains(2)
println("contains -> $contains")
val contains2 = list8.contains(null)
println("contains2 -> $contains2")
val contains3 = list8.contains("A")
println("contains3 -> $contains3")
val contains4 = list8.contains("C")
println("contains4 -> $contains4")
//打印结果
contains -> true
contains2 -> true
contains3 -> true
contains4 -> false

29.elementAt

返回指定索引位置的元素，如果索引超出集合则会抛出异常

val list = listOf<Any?>(1, 2, "A", null, "B")
val elementAt = list.elementAt(2)
println("elementAt -> $elementAt")
//打印 elementAt -> A

30.elementAtOrElse

返回指定索引位置的元素，如果超出边界，则返回默认的值

val list = listOf<Int>(0, 1, 2, 3, 4, 5)
val elementAtOrElse1 = list.elementAtOrElse(2) { 10086 }
println("elementAtOrElse1 -> $elementAtOrElse1")
val elementAtOrElse2 = list.elementAtOrElse(100) { 10086 }
println("elementAtOrElse2 -> $elementAtOrElse2")
//打印
elementAtOrElse1 -> 2
elementAtOrElse2 -> 10086

31.elementAtOrNull

返回指定索引位置的元素，如果超出边界，则返回null

val list = listOf<Int>(0, 1, 2, 3, 4, 5)
val elementAtOrNull1= list.elementAtOrNull(2) { 10086 }
println("elementAtOrNull1-> $elementAtOrNull1")
val elementAtOrNul2= list.elementAtOrNull(100) { 10086 }
println("elementAtOrNull2-> $elementAtOrNull2")
//打印
elementAtOrNull1-> 2
elementAtOrNull2-> null

32.first

1.返回集合中的第一个元素，如果数组为空，会抛出异常NoSuchElementException("List is empty.")
2.返回集合中满足条件的第一个元素，如果没有满足条件的也会抛出异常NoSuchElementException("Collection contains no element matching the predicate.")

val list = listOf<Int>(0, 1, 2, 3, 4, 5)
val first = list.first()
println("first -> $first")
val first2 = list.first { it > 3 }
println("first2 -> $first2")
//打印
first -> 0
first2 -> 4

33.firstOrNull

返回集合中满足的第一个元素，如果没有则返回null

val list = listOf<Int>(0, 1, 2, 3, 4, 5)
val first = list.firstOrNull{ it > 3 }
println("first -> $first ")
val first2 = list.firstOrNull{ it > 100 }
println("first2 -> $first2 ")
//打印
first -> 4
first2 -> null

34.indexOf

返回集合中指定元素的索引位置，没有则返回-1，用法同java

35.lastIndexOf

返回集合中指定元素的最后一个的索引位置，没有则返回-1,用法同java

36.indexOfFirst

返回集合中第一个满足条件的索引位置，没有则返回-1

37.indexOfLast

返回集合中最后一个满足条件的索引位置，没有则返回-1

val list = listOf<Int>(0, 1, 2, 3, 4, 5)
val indexOfFirst = list.indexOfFirst { it > 3 }
println("indexOfFirst -> $indexOfFirst ")
val indexOfLast = list.indexOfLast { it > 3 }
println("indexOfLast -> $indexOfLast ")
//打印
indexOfFirst -> 4
indexOfLast -> 5

38.last

1.返回集合中的最后一个元素，如果数组为空，会抛出异常NoSuchElementException("List is empty.")
2.返回集合中满足条件的最后一个元素，如果没有满足条件的也会抛出异常NoSuchElementException("Collection contains no element matching the predicate.")
使用方法同上面的first

39.lastOrNull

返回集合中满足的最后一个元素，如果没有则返回null
使用方法同上面的firstOrNull

40.single

返回集合满足条件的元素，如果没有或者超过1个则抛出异常，也就是说集合中必须有且仅有一个满足条件的，否则都会抛出异常java.util.NoSuchElementException: Collection contains no element matching the predicate或java.lang.IllegalArgumentException: Collection contains more than one matching element

val list = listOf<Int>(0, 1, 2, 3, 4, 5)
val single = list.single { it > 4 }
println("single -> $single")
//打印 single -> 5
val single2 = list.single { it > 1 }
//异常
val single3 = list.single { it > 10 }
//异常

41.singleOrNull

返回j集合中满足条件的元素，如果没有或者超过1个则返回null。
single例子里后两个值使用singleOrNull则不会抛异常，但是会返回null

42.zip

public infix fun <T, R> Iterable<T>.zip(other: Iterable<R>): List<Pair<T, R>> {
    return zip(other) { t1, t2 -> t1 to t2 }
}

public inline fun <T, R, V> Iterable<T>.zip(other: Iterable<R>, transform: (a: T, b: R) -> V): List<V> {
    val first = iterator()
    val second = other.iterator()
    val list = ArrayList<V>(minOf(collectionSizeOrDefault(10), other.collectionSizeOrDefault(10)))
    while (first.hasNext() && second.hasNext()) {
        list.add(transform(first.next(), second.next()))
    }
    return list
}

可以看出，zip方法最终返回的是一个List<Pair>结构的集合，transform方法则是把两个集合中的元素组装成一个Pair的过程，而组装的前提是当前索引位置上两个集合都是有元素的，也就是说，会以两个集合的最小长度组装，超出的会被丢弃。

val list = listOf<Int>(0, 1, 2, 3, 4, 5)
val list2 = listOf<String>("A","B","C","D")
val zip = list.zip(list2)
println("zip -> $zip")
//打印 
zip -> [(0, A), (1, B), (2, C), (3, D)]

明显，list集合中的最后一个元素被丢弃了

此外，zip也是可以自定义transform的

public inline fun <T, R, V> Iterable<T>.zip(other: Iterable<R>, transform: (a: T, b: R) -> V): List<V> {
    val first = iterator()
    val second = other.iterator()
    val list = ArrayList<V>(minOf(collectionSizeOrDefault(10), other.collectionSizeOrDefault(10)))
    while (first.hasNext() && second.hasNext()) {
        list.add(transform(first.next(), second.next()))
    }
    return list
}

这个方法最终也是会取两个集合的交集的元素进行处理后存放到一个新的集合中，超出的被丢弃

val list = listOf<Int>(0, 1, 2, 3, 4, 5)
val list2 = listOf<String>("A","B","C","D")
val zip2 = list.zip(list2) { origin, target -> "$origin:$target" }
println("zip2 -> $zip2")
//打印  
zip2 -> [0:A, 1:B, 2:C, 3:D]

43.unzip

public fun <T, R> Iterable<Pair<T, R>>.unzip(): Pair<List<T>, List<R>> {
    val expectedSize = collectionSizeOrDefault(10)
    val listT = ArrayList<T>(expectedSize)
    val listR = ArrayList<R>(expectedSize)
    for (pair in this) {
        listT.add(pair.first)
        listR.add(pair.second)
    }
    return listT to listR
}

可以看出，upzip是针对于Pair的，最终返回一个Pair<List,List>的结构
,因为是从Pair转化过去的，所以这两个List的大小最终一样。所以这个方法可以认为是把List<Pair>中的每个Pair的两个值拆开，分别放到两个集合中去，然后这两个集合再构建成一个新的Pair。前面的zip是操作两个List并最终返回List<Pair>这种结构的结果，而unzip则是把这种结构还原成原来的两个List，当然被丢弃的那部分就无法还原了。

val list = listOf<Int>(0, 1, 2, 3, 4, 5)
val list2 = listOf<String>("A","B","C","D")
val zip = list.zip(list2)
val unzip = zip.unzip()
println("unzip -> $unzip")
//打印 unzip -> ([0, 1, 2, 3], [A, B, C, D])

44.plus

把两个集合合并成同一个，类似于addAll ,可以用+号替代

val list = listOf<Int>(0, 1, 2, 3, 4, 5)
val list2 = listOf<String>("A","B","C","D")
val plus = list.plus(list9)
val plus2 = list + list9
println("plus -> $plus")
println("plus2 -> $plus2")
//打印
plus -> [0, 1, 2, 3, 4, 5, A, B, C, D]
plus2 -> [0, 1, 2, 3, 4, 5, A, B, C, D]

45.reversed

返回一个指定集合中的元素反转后的新的集合

46.sorted

返回一个指定集合自然排序后的集合，这个是从小到大升序的

47.sortedDescending

返回一个指定集合自然排序后的集合，这个是从大到小降序的

48.sortBy

根据指定的算法进行排序，这个是升序的。
其实是根据sortBy方法中返回的数值进行对应元素的排序

val sortArr = listOf<String>("first","second","third","forth")
    fun find(value: String): Int {
        when (value) {
            "first" -> return 1
            "second" -> return 2
            "third" -> return 3
            "forth" -> return 4
        }
        return -1;
    }

val sorted  = sortArr.sorted()
println("sorted -> $sorted")
val sortby = sortArr.sortedBy {find(it) }
println("sortby -> $sortby")
val sortby2 = sortArr.sortedByDescending { find(it) }
println("sortby2 -> $sortby2")
//打印结果
sorted -> [first, forth, second, third]
sortby -> [first, second, third, forth]
sortby2 -> [forth, third, second, first]

可以看出自然排序是以英文首字母有限排序，而我们定义了规则之后，会按照我们定义的规则进行大小判断然后排序

49.sortedByDescending

根据指定的算法进行排序，这个是降序的。
其实是根据sortBy方法中返回的数值进行对应元素的排序，上面有例子

50.partition

把一个集合按照一定的规则拆分成两个

public inline fun <T> Iterable<T>.partition(predicate: (T) -> Boolean): Pair<List<T>, List<T>> {
    val first = ArrayList<T>()
    val second = ArrayList<T>()
    for (element in this) {
        if (predicate(element)) {
            first.add(element)
        } else {
            second.add(element)
        }
    }
    return Pair(first, second)
}

可以看出，需要制定一个返回Boolean规则的方法，然后根据这个方法的返回值，会把一个集合的元素拆分成两个集合。

val list = listOf<Int>(0, 1, 2, 3, 4, 5)
val partition = list.partition { it % 2 == 0 }
println("partiton -> $partition")
//打印 
partiton -> ([0, 2, 4], [1, 3, 5])