在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 挑出该集合前n个元素的子集合,如果n等于0，返回空集；如果n大于集合 size ，返回该集合
val list = listOf(1, 3, 4)
println(list.take(2))
>>> [1, 3]
takeWhile(predicate: (T) -> Boolean): List 挑出满足条件的元素的子集合。
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 挑出后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 返回包含指定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) 返回指定下标的元素子集合
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 元素。
joinToString(separator: CharSequence = ", ", prefix: CharSequence = "", **postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((T) -> CharSequence)? = null): String
这个方法是将集合的元素有 **“条件”**的转换成字符串。方法的第一个参数separator用于指定集合元素之间的分隔符，prefix用于指定字符串的前缀，postfix用于指定字符串的前缀，limit是指从集合的第一元素开始一共取多少个，默认是-1表示取全部元素，truncated是用于指定，如果limit指定的数量少于集合的长度那么被舍弃的元素的占位符，默认是 ...，transform是对集合的元素是操作，操作后的元素作为结果输出，还是代码更清晰
val joinToString= (1..10)
.toList()
.filter { it > 5 }
.joinToString("==", prefix = "《《", postfix = "》》", limit = 4, truncated = "||")
创建了一个集合，元素是1到10，然后取出其中大于5的元素，此时集合的内容是[6,7,8,9,10]长度是5，根据joinToString所设置的条件，此时的输出结果是
《《6==7==8==9==||》》
由于limit是4，小于集合长度5，所以10被舍弃，用 || 代替，如果将limit设置成-1或者5那么结果将变成
《《6==7==8==9==10》》
接下来在看下transform的作用，如果此时集合的元素不是想要的，那么可以通过transform进行操作
val joinToString= (1..10)
.toList()
.filter { it > 5 }
.joinToString("==", prefix = "《《", postfix = "》》", limit = 5, truncated = "||") {
"数字:$it"
}
输出：
《《数字:6==数字:7==数字:8==数字:9==数字:10》》
windowed(size: Int, step: Int = 1, partialWindows: Boolean = false, transform: (List) -> R)
这个函数的大概意思就是 依次从左至右，以给定的step从原始List中每次取size个值，创建一个子List，最后再将这些创建的子List放入新的List中返回，其中需要注意下partialWindows 参数 当设置为true的时候表示，如果最后剩余的元素个数已经不足size个，那么直接将剩余的元素组成list，当设置为false的时候, 那么严格按照size的大小创建子List,如果元素不足size，那么直接舍弃。transform参数就很好理解了，也是表示如果原List的元素不满足要求的时候可以进行操作
//partialWindows==true
val windowed = (1..10).toList().windowed(3, 1, true)
输出
[[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6], [5, 6, 7], [6, 7, 8], [7, 8, 9], [8, 9, 10], [9, 10], [10]]
//partialWindows==false
val windowed = (1..10).toList().windowed(3, 1, false)
输出
[[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6], [5, 6, 7], [6, 7, 8], [7, 8, 9], [8, 9, 10]]
//对原List元素进行变换
val windowed = (1..10).toList().windowed(3, 1, false) {
it.map { e -> e + 1 }
}
输出
[[2, 3, 4], [3, 4, 5], [4, 5, 6], [5, 6, 7], [6, 7, 8], [7, 8, 9], [8, 9, 10], [9, 10, 11]]
