Kotlin学习：集合<2>.List操作符

在java中，如果我们要判断List集合中的某个元素是否符合判断条件，会有如下代码

 public static void main(String[] args) {
        ArrayList<String> list = createList();
        String matchResult = null;
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i).contains("a")) {
                matchResult = list.get(i);
                break;
            }
        }
        System.out.println(matchResult);
    }
    private static ArrayList<String> createList() {
        ArrayList<String> list = new ArrayList<>();
        list.add("bc");
        list.add("bdf");
        list.add("cca");
        list.add("bbc");
        list.add("efg");
        return list;
    }
>>>cca

for循环这一段模版代码，可能在不同的方法中会多次的用到，而大量的模版代码只会增加工作量。为此，kotlin里封装了很多List集合操作符，方便我们的使用

any() 如果集合至少有一个元素，返回 true ，否则返回 false 。

val emptyList = listOf<Int>()
emptyList.any()
>>>false

val list1 = listOf(1)
list1.any()
>>>true

any(predicate: (T) -> Boolean): Boolean 如果至少有一个元素符合给定条件predicate，返回true，否则返回false

val list = listOf(1, 2, 3)
// 元素2满足{it%2==0}
list.any({it%2==0}) 
>>>true

// 没有元素满足{it>4}
list.any({it>4}) 
>>>false

all(predicate: (T) -> Boolean): Boolean 如果List集合的全部元素都满足给定条件predicate，那么返回true，否则返回false

val list = listOf(0,2,4,6,8)
 list.all({it%2==0})
>>>true
 list.all({it>2})
>>>false

none() 如果集合没有任何元素，返回true，否则返回false

val list = listOf<Int>()
 list.none()
>>>true

none(predicate: (T) -> Boolean): Boolean 如果集合元素全都不满足给定条件predicate，返回true，否则返回false

val list = listOf(0,2,4,6,8)
list.none({it%2==1})
>>> true
list.none({it>0})
>>> false

count()计算集合中元素的个数

val list = listOf(0,2,4,6,8,9)
 list.count()
>>>6

如果点进去查看这个count()函数的源码，会发现，它是直接把List集合的size返回了

public inline fun <T> Collection<T>.count(): Int {
    return size
}

我看到这个函数源码的时候，觉得这个封装有点鸡肋，后来一想，这样写的好处可能是为了方便链式调用吧

count(predicate: (T) -> Boolean): Int 返回集合中满足给定条件predicate的元素的数量

val list = listOf(0,2,4,6,8,9)
 list.count({it%2==0})
>>> 5

reduce(operation: (acc: S, T) -> S): S 以集合第一个元素为初始值，从第一项到最后一项根据operation累计运算，这个操作符结合着源码看更容易理解些

public inline fun <S, T : S> Iterable<T>.reduce(operation: (acc: S, T) -> S): S {
1.    val iterator = this.iterator()
2.   if (!iterator.hasNext()) throw UnsupportedOperationException("Empty collection can't be reduced.")
3.    var accumulator: S = iterator.next()
4.     while (iterator.hasNext()) {
5.         accumulator = operation(accumulator, iterator.next())
6. }
7. return accumulator
}

代码示例

 val list= listOf(1,2,3)
 val result = list.reduce { s, t ->
        print("s=$s ")
        print("t=$t")
        println()
        s + t
    }
    println(result)
>>> s=1 t=2
>>> s=3 t=3
>>> result=6

结合着示例代码，我们在看源码就很容易了，这个函数就是把集合的第一元素赋值给变量accumulator，源码的第3行。然后开始遍历这个集合，并且把当前的accumulator值和集合的下一个值回调给operation，再把operation函数的返回值重新赋值给accumulator，如此重复，源码4、5行。最后把最终的运算结果accumulator返回

reduceIndexed(operation: (index: Int, acc: S, T) -> S): S 这个函数和reduce函数的区别就是加入了集合的下标，如果需要用到下标就用这个，不需要下标就用reduce

reduceRight(operation: (T, acc: S) -> S): S 以集合最后一个元素为初始值，从最后一项到第一项根据operation累计运算

 val list = listOf("1", "2", "3")
  val result = list.reduceRight { i, acc ->
         i + acc
    }
>>> 123

reduceRight 操作符使用的时候需要注意的是，在拼接字符串的时候i + acc 和 acc + i结果是不同的

 val list = listOf("1", "2", "3")
  val result = list.reduceRight { i, acc ->
         acc + i
    }
>>> 321

reduceRightIndexed(operation: (index: Int, T, acc: S) -> S): S 这个函数和**reduceRight **的区别也是加入了下标。

fold(initial: R, operation: (acc: R, T) -> R): R 以initial为初始值，从第一项到最后一项根据operation累计运算。这个操作符就相当于是带初始值的reduce

 val list=listOf(1,2,3,4)
 list.fold(10,{total, next -> next + total})
>>> 20

foldIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): R 和fold的区别也是将集合元素对应的下标一并回调给operation

foldRight(initial: R, operation: (T, acc: R) -> R): R 以initial为初始值，从最后一项到第一项根据operation累计运算。这个操作符就相当于是带初始值的reduceRight

val list = listOf("a","b","c")
list.foldRight("xyz",{s, pre -> pre + s})
>>> xyzcba

拼接字符串的时候同样需要注意顺序
reduceRightIndexed(operation: (index: Int, T, acc: S) -> S): S 和foldRight的区别也是将集合元素对应的下标一并回调给operation

forEach(action: (T) -> Unit): Unit 遍历集合

val list = listOf(0, 1, 2, 3, 4)
list.forEach { value -> print(value) }
>>> 01234

forEachIndexed(action: (index: Int, T) -> Unit): Unit 带下标遍历集合

 val list = listOf("1", "2", "3")
    list.forEachIndexed { index, value ->
        print("index=$index,value=$value ")
    }
>>>index=0,value=1 index=1,value=2 index=2,value=3

max(): T? 返回集合中最大的元素。字符串也可以直接比较，字符串的大小比较是按照对应的下标的字符进行比较的。 另外，布尔值的比较是 true 大于 false ：

 val list = listOf(1, 3,4 )
    println(list.max())
    >>>4
    val strList = listOf("你", "我","他" )
    println(strList.max())
    >>>我

maxBy(selector: (T) -> R): T? 获取selector运算后的最大值对应的那个元素的值，如果集合为空则直接返回null，概念比较抽象，结合者源码就很容易理解了

public inline fun <T, R : Comparable<R>> Iterable<T>.maxBy(selector: (T) -> R): T? {
    val iterator = iterator()
    if (!iterator.hasNext()) return null
    var maxElem = iterator.next()
    if (!iterator.hasNext()) return maxElem
    var maxValue = selector(maxElem)
    do {
        val e = iterator.next()
        val v = selector(e)
        if (maxValue < v) {
            maxElem = e
            maxValue = v
        }
    } while (iterator.hasNext())
    return maxElem
} 

不直接比较集合元素的大小，而是以集合元素为入参的函数 selector: (T) -> R 返回值来比较大小，最后返回此元素的值（注意，不是对应的 selector 函数的返回值）

  val list = listOf(1, 3, 4)
    println( list.maxBy {
        it > 3
    })
>>>4

这里需要注意的一点是，上面提到过，boolean值比较大小的时候true大于false

minBy(selector: (T) -> R): T? 获取传参函数selector运算后的最小值对应的那个元素的值，如果集合为空则直接返回null。和maxby类似只不过返回最小值。

sum() 返回集合中所有元素的和。
sumBy(selector: (T) -> Int): Int 返回应用于集合中每个元素的[selector]函数生成的所有值的总和。

val list = listOf(1,2,3,4)
list.sumBy({it})
>>> 10
list.sumBy({it*it})
>>> 30

sumBy 函数返回值是 Int 。它的入参 selector 是一个函数类型 (T) -> Int ，也就是说这个selector也是返回Int类型的函数。

take(n: Int): List<T> 挑出该集合前n个元素的子集合,如果n等于0，返回空集；如果n大于集合 size ，返回该集合

val list = listOf(1, 3, 4)
    println(list.take(2))
>>> [1, 3]

takeWhile(predicate: (T) -> Boolean): List<T> 挑出满足条件的元素的子集合。

public inline fun <T> Iterable<T>.takeWhile(predicate: (T) -> Boolean): List<T> {
    val list = ArrayList<T>()
    for (item in this) {
        if (!predicate(item))
            break
        list.add(item)
    }
    return list
}

从第一个元素开始，判断是否满足 predicate 为true，如果满足条件的元素就添加到返回 ArrayList 中。只要遇到任何一个元素不满足条件，就结束循环，返回list 。

takeLast(n: Int): List<T> 挑出后n个元素的子集合。从集合倒数n个元素起，取出到最后一个元素的子集合。如果传入0，返回空集。如果传入n大于集合size，返回整个集合。如果传入负数，直接抛出IllegalArgumentException。

takeLastWhile(predicate: (T) -> Boolean) 从最后开始挑出满足条件元素的子集合，遇到不满足的元素，直接终止循环，并返回子集合
drop(n: Int) 去除前n个元素返回剩下的元素的子集合
dropWhile(predicate: (T) -> Boolean) 去除满足条件的元素返回剩下的元素的子集合，当遇到一个不满足条件的元素时，中止操作，返回剩下的元素子集合。

val list = listOf(1, 3, 4)
println(list.dropWhile1 {it>3 })
>>>[1, 3, 4]

示例代码中，判断条件是大于3的元素，而集合中第一个元素是1，不满足条件，所以直接将1和剩下的元素放入集合返回
dropLast(n: Int) 从集合最后去除n个元素
dropLastWhile(predicate: (T) -> Boolean) 从最后去除满足条件的元素
slice(indices: IntRange): List<T> 返回包含指定indices范围内元素的子集合。

val list = listOf(2,4,6,8,9,11,12,16)
 list.slice(1..3)
>>>[4, 6, 8]
list.slice(2..7)
>>> [6, 8, 9, 11, 12, 16]

slice(indices: Iterable<Int>) 返回指定下标的元素子集合

val list = listOf(2,4,6,8,9,11,12,16)
list.slice(listOf(2,4,6))
>>>[6, 9, 12]

filterTo(destination: C, predicate: (T) -> Boolean)取出满足条件的元素并赋值给destination

val list = listOf(1,2,3,4,5,6,7)
val dest = mutableListOf<Int>()
list.filterTo(dest,{it>3})
>>>[4, 5, 6, 7]

filter(predicate: (T) -> Boolean) 返回满足条件元素的子集合，这个函数直接调用的filterTo,如果对返回的子集合没有特殊要求，使用这个函数更简便。另外，还有下面常用的过滤函数filterNot(predicate: (T) -> Boolean) 用来过滤所有不满足条件的元素 ； filterNotNull()过滤掉 null 元素。