在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 元素。
