5.3.6 过滤操作函数

take(n: Int): List<T> 挑出该集合前n个元素的子集合

函数定义：

1. public fun <T> Iterable<T>.take(n: Int): List<T> {
2. require(n >= 0) { "Requested element count $n is less than zero." }
3. if (n == 0) return emptyList()
4. if (this is Collection<T>) {
5. if (n >= size) return toList()
6. if (n == 1) return listOf(first())
7. }
8. var count = 0
9. val list = ArrayList<T>(n)
10. for (item in this) {
11. if (count++ == n)
12. break
13. list.add(item)
14. }
15. return list.optimizeReadOnlyList()
16. }

如果n等于0，返回空集；如果n大于集合size，返回该集合。

代码示例：

1. >>> val list = listOf("a","b","c")
2. >>> list
3. [a, b, c]
4. >>> list.take(2)
5. [a, b]
6. >>> list.take(10)
7. [a, b, c]
8. >>> list.take(0)
9. []

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

13. 函数定义：

15. ```kotlin
16. public inline fun <T> Iterable<T>.takeWhile(predicate: (T) -> Boolean): List<T> {
17. val list = ArrayList<T>()
18. for (item in this) {
19. if (!predicate(item))
20. break
21. list.add(item)
22. }
23. return list
24. }

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

代码示例：

1. >>> val list = listOf(1,2,4,6,8,9)
2. >>> list.takeWhile({it%2==0})
3. []
4. >>> list.takeWhile({it%2==1})
5. [1]

7. >>> val list = listOf(2,4,6,8,9,11,12,16)
8. >>> list.takeWhile({it%2==0})
9. [2, 4, 6, 8]

11. ```#### `takeLast` 挑出后n个元素的子集合

13. 函数定义：

15. ```kotlin
16. public fun <T> List<T>.takeLast(n: Int): List<T> {
17. require(n >= 0) { "Requested element count $n is less than zero." }
18. if (n == 0) return emptyList()
19. val size = size
20. if (n >= size) return toList()
21. if (n == 1) return listOf(last())
22. val list = ArrayList<T>(n)
23. if (this is RandomAccess) {
24. for (index in size - n .. size - 1)
25. list.add(this[index])
26. } else {
27. for (item in listIterator(n))
28. list.add(item)
29. }
30. return list
31. }

从集合倒数n个元素起，取出到最后一个元素的子集合。如果传入0，返回空集。如果传入n大于集合size，返回整个集合。如果传入负数，直接抛出IllegalArgumentException。

代码示例：

1. >>> val list = listOf(2,4,6,8,9,11,12,16)
2. >>> list.takeLast(0)
3. []
4. >>> list.takeLast(3)
5. [11, 12, 16]
6. >>> list.takeLast(100)
7. [2, 4, 6, 8, 9, 11, 12, 16]
8. >>> list.takeLast(-1)
9. java.lang.IllegalArgumentException: Requested element count -1 is less than zero.
10. at kotlin.collections.CollectionsKt___CollectionsKt.takeLast(_Collections.kt:734)

12. ```#### `takeLastWhile(predicate: (T) -> Boolean)` 从最后开始挑出满足条件元素的子集合

14. 函数定义：

16. ```kotlin
17. public inline fun <T> List<T>.takeLastWhile(predicate: (T) -> Boolean): List<T> {
18. if (isEmpty())
19. return emptyList()
20. val iterator = listIterator(size)
21. while (iterator.hasPrevious()) {
22. if (!predicate(iterator.previous())) {
23. iterator.next()
24. val expectedSize = size - iterator.nextIndex()
25. if (expectedSize == 0) return emptyList()
26. return ArrayList<T>(expectedSize).apply {
27. while (iterator.hasNext())
28. add(iterator.next())
29. }
30. }
31. }
32. return toList()
33. }

反方向取满足条件的元素，遇到不满足的元素，直接终止循环，并返回子集合。

代码示例：

1. >>> val list = listOf(2,4,6,8,9,11,12,16)
2. >>> list.takeLastWhile({it%2==0})
3. [12, 16]
4. ```#### `drop(n: Int)` 去除前n个元素返回剩下的元素的子集合

6. 函数定义：

8. ```kotlin
9. public fun <T> Iterable<T>.drop(n: Int): List<T> {
10. require(n >= 0) { "Requested element count $n is less than zero." }
11. if (n == 0) return toList()
12. val list: ArrayList<T>
13. if (this is Collection<*>) {
14. val resultSize = size - n
15. if (resultSize <= 0)
16. return emptyList()
17. if (resultSize == 1)
18. return listOf(last())
19. list = ArrayList<T>(resultSize)
20. if (this is List<T>) {
21. if (this is RandomAccess) {
22. for (index in n..size - 1)
23. list.add(this[index])
24. } else {
25. for (item in listIterator(n))
26. list.add(item)
27. }
28. return list
29. }
30. }
31. else {
32. list = ArrayList<T>()
33. }
34. var count = 0
35. for (item in this) {
36. if (count++ >= n) list.add(item)
37. }
38. return list.optimizeReadOnlyList()
39. }

代码示例：

1. >>> val list = listOf(2,4,6,8,9,11,12,16)
2. >>> list.drop(5)
3. [11, 12, 16]
4. >>> list.drop(100)
5. []
6. >>> list.drop(0)
7. [2, 4, 6, 8, 9, 11, 12, 16]
8. >>> list.drop(-1)
9. java.lang.IllegalArgumentException: Requested element count -1 is less than zero.
10. at kotlin.collections.CollectionsKt___CollectionsKt.drop(_Collections.kt:538)
11. ```#### `dropWhile(predicate: (T) -> Boolean)` 去除满足条件的元素返回剩下的元素的子集合

13. 函数定义：

15. ```kotlin
16. public inline fun <T> Iterable<T>.dropWhile(predicate: (T) -> Boolean): List<T> {
17. var yielding = false
18. val list = ArrayList<T>()
19. for (item in this)
20. if (yielding)
21. list.add(item)
22. else if (!predicate(item)) {
23. list.add(item)
24. yielding = true
25. }
26. return list
27. }

去除满足条件的元素，当遇到一个不满足条件的元素时，中止操作，返回剩下的元素子集合。

代码示例：

1. >>> val list = listOf(2,4,6,8,9,11,12,16)
2. >>> list.dropWhile({it%2==0})
3. [9, 11, 12, 16]

5. ```#### `dropLast(n: Int)` 从最后去除n个元素

7. 函数定义：

9. ```kotlin
10. public fun <T> List<T>.dropLast(n: Int): List<T> {
11. require(n >= 0) { "Requested element count $n is less than zero." }
12. return take((size - n).coerceAtLeast(0))
13. }

代码示例：

1. >>> val list = listOf(2,4,6,8,9,11,12,16)
2. >>> list.dropLast(3)
3. [2, 4, 6, 8, 9]
4. >>> list.dropLast(100)
5. []
6. >>> list.dropLast(0)
7. [2, 4, 6, 8, 9, 11, 12, 16]
8. >>> list.dropLast(-1)
9. java.lang.IllegalArgumentException: Requested element count -1 is less than zero.
10. at kotlin.collections.CollectionsKt___CollectionsKt.dropLast(_Collections.kt:573)
11. ```#### `dropLastWhile(predicate: (T) -> Boolean)` 从最后满足条件的元素

13. 函数定义：

15. ```kotlin
16. public inline fun <T> List<T>.dropLastWhile(predicate: (T) -> Boolean): List<T> {
17. if (!isEmpty()) {
18. val iterator = listIterator(size)
19. while (iterator.hasPrevious()) {
20. if (!predicate(iterator.previous())) {
21. return take(iterator.nextIndex() + 1)
22. }
23. }
24. }
25. return emptyList()
26. }

代码示例：

1. >>> val list = listOf(2,4,6,8,9,11,12,16)
2. >>> list.dropLastWhile({it%2==0})
3. [2, 4, 6, 8, 9, 11]
4. ```#### `slice(indices: IntRange)` 取开始下标至结束下标元素子集合

6. 函数定义：

8. ```kotlin
9. public fun <T> List<T>.slice(indices: IntRange): List<T> {
10. if (indices.isEmpty()) return listOf()
11. return this.subList(indices.start, indices.endInclusive + 1).toList()
12. }

代码示例：

1. val list = listOf(2,4,6,8,9,11,12,16)
2. >>> list
3. [2, 4, 6, 8, 9, 11, 12, 16]
4. >>> list.slice(1..3)
5. [4, 6, 8]
6. >>> list.slice(2..7)
7. [6, 8, 9, 11, 12, 16]
8. >>> list
9. [2, 4, 6, 8, 9, 11, 12, 16]
10. >>> list.slice(1..3)
11. [4, 6, 8]
12. >>> list.slice(2..7)
13. [6, 8, 9, 11, 12, 16]
14. ```#### `slice(indices: Iterable<Int>) `返回指定下标的元素子集合

16. 函数定义：

18. ```kotlin
19. public fun <T> List<T>.slice(indices: Iterable<Int>): List<T> {
20. val size = indices.collectionSizeOrDefault(10)
21. if (size == 0) return emptyList()
22. val list = ArrayList<T>(size)
23. for (index in indices) {
24. list.add(get(index))
25. }
26. return list
27. }

这个函数从签名上看，不是那么简单直接。从函数的定义看，这里的indices是当做原来集合的下标来使用的。

代码示例：

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

我们可以看出，这里是取出下标为2，4，6的元素。而不是直观理解上的，去掉元素2，4，6。#### filterTo(destination: C, predicate: (T) -> Boolean) 过滤出满足条件的元素并赋值给destination

函数定义：

1. public inline fun <T, C : MutableCollection<in T>> Iterable<T>.filterTo(destination: C, predicate: (T) -> Boolean): C {
2. for (element in this) if (predicate(element)) destination.add(element)
3. return destination
4. }

把满足过滤条件的元素组成的子集合赋值给入参destination。

代码示例：

1. >>> val list = listOf(1,2,3,4,5,6,7)
2. >>> val dest = mutableListOf<Int>()
3. >>> list.filterTo(dest,{it>3})
4. [4, 5, 6, 7]
5. >>> dest
6. [4, 5, 6, 7]
7. ```#### `filter(predicate: (T) -> Boolean)`过滤出满足条件的元素组成的子集合

9. 函数定义：

11. ```kotlin
12. public inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T> {
13. return filterTo(ArrayList<T>(), predicate)
14. }

相对于filterTo函数，filter函数更加简单易用。从源码我们可以看出，filter函数直接调用的filterTo(ArrayList<T>(), predicate)， 其中入参destination被直接默认赋值为ArrayList<T>()。

代码示例：

1. >>> val list = listOf(1,2,3,4,5,6,7)
2. >>> list.filter({it>3})
3. [4, 5, 6, 7]

另外，还有下面常用的过滤函数：

filterNot(predicate: (T) -> Boolean), 用来过滤所有不满足条件的元素 ； filterNotNull() 过滤掉null元素。