kotlin学习day6：集合和操作符_kotlin indexoffirst

Kotlin和Java相比，在使用集合的时候结合了组多强大的函数操作符，这样带来的好处就是使用者不用解释怎么去做，而是直接说我想做什么。比如，我想去过滤一个list，我不用去创建一个list，然后去遍历它，将符合条件的每一项放到一个新的集合中，而是直接使用filter函数并指明我想用的过滤器。使用这种方式，可以为我们省去大量代码。

Kotlin提供的一些本地接口：

1. Iterable：父类。所有我们可以遍历一系列的都是实现这个接口。
2. MutableIterable：一个支持遍历的同时可以执行删除的Iterables。
3. Collection：这个类相是一个范性集合。我们通过函数访问可以返回集合的
   size、是否为空、是否包含一个或者一些item。这个集合的所有方法提供查
   询，因为connections是不可修改的。
4. MutableCollection：一个支持增加和删除item的Collection。它提供了额外的函数，比如 add 、 remove 、 clear 等等。
5. List：可能是最流行的集合类型。它是一个范性有序的集合。因为它的有序，我们可以使用 get 函数通过position来访问。
6. MutableList：一个支持增加和删除item的List。
7. Set：一个无序并不支持重复item的集合。
8. MutableSet：一个支持增加和删除item的Set。
9. Map：一个key-value对的collection。key在map中是唯一的，也就是说不能有两对key是一样的键值对存在于一个map中。
10. MutableMap：一个支持增加和删除item的map。

为了演示这些操作符的使用，我们先来创建一个集合：

  val list = listOf(1, 2, 3, 4, 5)
1

1.总数操作符

---

any：如果至少有一个元素符合给出的判断条件，返回true：

  Log.i("Lbjfan any:", list.any { it % 2 == 0 }.toString())
1

运行结果：

09-04 20:39:36.867 3239-3239/com.example.lbjfan.kotlindemo I/Lbjfan any:: true
1

all:如果全部的元素都符合给出的判断条件，则返回true

 Log.i("Lbjfan all:", list.all { it % 2 == 0 }.toString())
1

运行结果：

09-04 20:39:36.867 3239-3239/com.example.lbjfan.kotlindemo I/Lbjfan all:: false
1

count:返回符合给出判断条件的元素总数

Log.i("Lbjfan count", list.count { it % 2 == 0 }.toString())
1

运行结果：

09-04 20:39:36.867 3239-3239/com.example.lbjfan.kotlindemo I/Lbjfan count: 2
1

fold:在一个初始值的基础上，从第一项到最后一项通过一个函数累计所有的元素

        Log.i("Lbjfan fold", list.fold(1) { total, next -> total + next }.toString())
1
2

运行结果：

09-04 20:39:36.867 3239-3239/com.example.lbjfan.kotlindemo I/Lbjfan fold: 16
1

foldRight:在一个初始值的基础上，从最后一项到第一项通过一个函数累计所有的元素

   Log.i("Lbjfan fold", list.fold(1) { total, next -> total + next }.toString())
1

运行结果：

09-04 20:39:36.867 3239-3239/com.example.lbjfan.kotlindemo I/Lbjfan fold: 16
1

forEach：遍历所有元素，并执行给定的操作

list.forEach { Log.i("Lbjfan forEach:", it.toString()) }
1

运行结果：

09-04 20:39:36.867 3239-3239/com.example.lbjfan.kotlindemo I/Lbjfan forEach:: 1
09-04 20:39:36.867 3239-3239/com.example.lbjfan.kotlindemo I/Lbjfan forEach:: 2
09-04 20:39:36.867 3239-3239/com.example.lbjfan.kotlindemo I/Lbjfan forEach:: 3
09-04 20:39:36.867 3239-3239/com.example.lbjfan.kotlindemo I/Lbjfan forEach:: 4
09-04 20:39:36.868 3239-3239/com.example.lbjfan.kotlindemo I/Lbjfan forEach:: 5
1
2
3
4
5

forEachIndexed：遍历所有元素，并执行给定的操作，与forEach相比，可以得到每个元素的index

list.forEachIndexed { position, value -> Log.i("forEachIndexed", "position:$position->value:$value") }
1

运行结果：

09-04 20:39:36.868 3239-3239/com.example.lbjfan.kotlindemo I/forEachIndexed: position:0->value:1
09-04 20:39:36.868 3239-3239/com.example.lbjfan.kotlindemo I/forEachIndexed: position:1->value:2
09-04 20:39:36.868 3239-3239/com.example.lbjfan.kotlindemo I/forEachIndexed: position:2->value:3
09-04 20:39:36.868 3239-3239/com.example.lbjfan.kotlindemo I/forEachIndexed: position:3->value:4
09-04 20:39:36.868 3239-3239/com.example.lbjfan.kotlindemo I/forEachIndexed: position:4->value:5
1
2
3
4
5

max：返回最大的一项，如果没有返回null

Log.i("Lbjfan max:", list.max().toString())
1

运行结果：

09-04 21:02:11.601 24892-24892/? I/Lbjfan max:: 5
1

maxBy:根据给定的函数返回最大的一项，如果没有返回null

Log.i("Lbjfan maxBy:", list.maxBy { -it }.toString())
1

运行结果：

09-04 21:02:11.601 24892-24892/? I/Lbjfan maxBy:: 1
1

min：返回最小的一项，如果没有返回null

Log.i("Lbjfan min:", list.min().toString())
1

运行结果

09-04 21:02:11.601 24892-24892/? I/Lbjfan min:: 1
1

minBy：根据给定的函数返回最小的一项，如果没有返回null

Log.i("Lbjfan minBy:", list.minBy { -it }.toString())
1

运行结果：

09-04 21:02:11.601 24892-24892/? I/Lbjfan minBy:: 5
1

none：如果没有任何元素与给定的函数匹配，则返回true

Log.i("Lbjfan none:", list.none { it == 6 }.toString())
1

运行结果

09-04 21:12:16.684 2352-2352/? I/Lbjfan none:: true
1

reduce：通过一个函数从第一项到最后一项进行累计，无初始值

Log.i("Lbjfan reduce:", list.reduce { total, next -> total - next }.toString())
1

运行结果：

09-04 21:12:16.684 2352-2352/? I/Lbjfan reduce:: -13
1

reduceRight：通过一个函数从最后一项到第一项进行累计，无初始值

        Log.i("Lbjfan reduceRight:", list.reduceRight { total, next -> total - next }.toString())
1
2

运结结果：

09-04 21:12:16.684 2352-2352/? I/Lbjfan reduceRight:: 3
1

sumBy：返回所有每一项通过函数转换后的数据总和

Log.i("Lbjfan sumBy:", list.sumBy { it - 1 }.toString())
1

运行结果：

09-04 21:12:16.684 2352-2352/? I/Lbjfan sumBy:: 10
1

2.过滤操作符

---

drop：返回包含去掉前N个元素列表

Log.i("Lbjfan drop:", list.drop(4).toString())
1

运行结果：

09-04 21:38:33.994 29336-29336/com.example.lbjfan.kotlindemo I/Lbjfan drop:: [5]
1

dropWhile：返回根据给定函数从第一项开始去掉指定元素的列表

Log.i("Lbjfan dropWhile:", list.dropWhile { it <= 2 }.toString())
1

运行结果：

09-04 21:38:33.994 29336-29336/com.example.lbjfan.kotlindemo I/Lbjfan dropWhile:: [3, 4, 5]
1

dropLastWhile:返回根据给定函数从最后一项开始去掉指定元素的列表

Log.i("Lbjfan dropLastWhile:", list.dropLastWhile { it > 2 }.toString())
1

运行结果：

09-04 21:43:34.293 2595-2595/? I/Lbjfan dropLastWhile:: [1, 2]
1

filter:过滤所有符合给定函数条件的元素(返回一个满足给定函数元素组成的新集合)

Log.i("Lbjfan filter", list.filter { it % 2 == 0 }.toString())
1

运行结果：

09-05 22:49:50.632 744-744/com.example.admin.kotlindemo I/Lbjfan filter: [2, 4]
1

filterNot:过滤所有不符合给定函数条件的元素（返回一个不满足给定函数元素组成的新集合）

Log.i("Lbjfan filterNot", list.filterNot { it % 2 == 0 }.toString())
1

运行结果：

09-05 22:49:50.632 744-744/com.example.admin.kotlindemo I/Lbjfan filterNot: [1, 3, 5]
1

filterNotNull:过滤所有元素中不是Null的元素

        Log.i("Lbjfan filterNotNull", list.filterNotNull().toString())
1
2

运行结果：

09-05 22:49:50.644 744-744/com.example.admin.kotlindemo I/Lbjfan filterNotNull: [1, 2, 3, 4, 5]
1

slice:过滤一个list中指定的index元素(若index>length，则会发生异常)

 Log.i("Lbjfan slice", list.slice(listOf(1, 2)).toString())
1

运行结果：

09-05 23:04:33.861 14692-14692/com.example.admin.kotlindemo I/Lbjfan slice: [2, 3]
1

take：返回从第一个开始的n个元素

Log.i("Lbjfan take", list.take(3).toString())
1

运行结果：

09-05 23:04:33.861 14692-14692/com.example.admin.kotlindemo I/Lbjfan take: [1, 2, 3]
1

takeLast：返回从最后一个开始的n个元素

Log.i("Lbjfan takelast", list.takeLast(3).toString())
1

运行结果：

09-05 23:04:33.861 14692-14692/com.example.admin.kotlindemo I/Lbjfan takelast: [3, 4, 5]
1

takeWhile：返回从第一个开始符合给定函数条件元素的函数

09-05 23:04:33.861 14692-14692/com.example.admin.kotlindemo I/Lbjfan takeWhile: [1, 2, 3, 4, 5]
1

3.映射操作符

---

flatMap:遍历所有的元素，为每一个元素创建一个新的集合，最后将所有的集合放在一个新的集合中

Log.i("Lbjfan flatMap", list.flatMap { listOf(it, it * 2) }.toString())
1

运行结果：

09-05 23:23:21.958 31665-31665/com.example.admin.kotlindemo I/Lbjfan flatMap: [1, 2, 2, 4, 3, 6, 4, 8, 5, 10]
1

groupBy:返回一个根据给定函数分组后的map（key是给定函数的返回值，value是该元素）

Log.i("Lbjfan groupBy", list.groupBy { it % 2 == 0 }.toString())
1

运行结果：

09-05 23:28:31.648 4589-4589/com.example.admin.kotlindemo I/Lbjfan groupBy: {false=[1, 3, 5], true=[2, 4]}
1

map:返回每一个元素根据给定函数转换后组成的集合（感觉和flatMap效果一样）

Log.i("Lbjfan map", list.map { it + 1 }.toString())
1

运行结果：

09-05 23:35:02.685 11017-11017/com.example.admin.kotlindemo I/Lbjfan map: [2, 3, 4, 5, 6]
1

mapIndexed:返回一个每一个元素根据给定的包含元素index的函数转换后的集合

 Log.i("Lbjfan mapIndexed", list.mapIndexed { index, i -> index * i }.toString())
1

运行结果：

09-05 23:39:12.168 14802-14802/com.example.admin.kotlindemo I/Lbjfan mapIndexed: [0, 2, 6, 12, 20]
1

mapNotNull：返回每一个元素根据给定函数转换后组成的集合

Log.i("Lbjfan mapNotNull", list.mapNotNull { it % 2 == 0 }.toString())```
1
2

运行结果：

09-05 23:44:13.762 19374-19374/com.example.admin.kotlindemo I/Lbjfan mapNotNull: [false, true, false, true, false]
1

4.元素操作符

---

contains：如果集合中包含指定元素，返回true

Log.i("Lbjfan contains", list.contains(6).toString())
1

运行结果：

09-06 00:08:02.530 10089-10089/com.example.admin.kotlindemo I/Lbjfan contains: false
1

elementAt:返回给定的index对应的元素，如果index数组越界，则会出现IndexOutOfBoundsExeption

Log.i("Lbjfan elementAt", list.elementAt(4).toString())
1

运行结果：

09-06 00:08:02.531 10089-10089/com.example.admin.kotlindemo I/Lbjfan elementAt: 5
1

elementAtOrElse:返回给定index
对应的元素，如果index数组越界，则会返回根据给定该函数和index计算后的元素

Log.i("Lbjfan elementAtOrElse", list.elementAtOrElse(7, { it * 2 }).toString())
1

运行结果：

09-06 00:08:02.531 10089-10089/com.example.admin.kotlindemo I/Lbjfan elementAtOrElse: 14
1

elementAtNull:返回给定index对应的元素，如果index数组越界,则会返回null

Log.i("Lbjfan elemenAtOrNull", list.elementAtOrNull(6).toString())
1

运行结果：

09-06 00:08:02.544 10089-10089/com.example.admin.kotlindemo I/Lbjfan elemenAtOrNull: null
1

first：返回符合给定函数条件的第一个元素

 Log.i("Lbjfan first", list.first { it % 2 == 0 }.toString())
1

运行结果：

09-06 00:31:27.235 30980-30980/com.example.admin.kotlindemo I/Lbjfan first: 2
1

firstOrNull:返回符合给定函数条件的第一个元素，如果没有，返回null

Log.i("Lbjfan firstOrNull", list.firstOrNull { it % 6 == 0 }.toString())
1

运行结果：

09-06 00:31:27.235 30980-30980/com.example.admin.kotlindemo I/Lbjfan firstOrNull: null
1

indexOf：返回指定元素的第一个index，如果不存在，则返回-1

Log.i("Lbjfan indexOf", list.indexOf(4).toString())
1

运行结果：

09-06 00:31:27.235 30980-30980/com.example.admin.kotlindemo I/Lbjfan indexOf: 3
1

indexOfFirst:返回第一个满足给定函数条件的index，如果没有则返回-1

Log.i("Lbjfan indexOfFirst", list.indexOfFirst { it % 2 == 0 }.toString())
1

运行结果：

09-06 00:31:27.235 30980-30980/com.example.admin.kotlindemo I/Lbjfan indexOfFirst: 1
1

indexOfLast:返回最后一个满足给定函数条件的index，如果没有返回-1

Log.i("Lbjfan indexOfLast", list.indexOfLast { it % 2 == 0 }.toString())
1

运行结果：

09-06 00:31:27.235 30980-30980/com.example.admin.kotlindemo I/Lbjfan indexOfLast: 3
1

last:返回符合给定函数条件的最后一个元素

 Log.i("Lbjfan last", list.last { it % 2 == 0 }.toString())
1

运行结果：

09-06 00:50:04.561 16631-16631/com.example.admin.kotlindemo I/Lbjfan last: 4
1

lastOfIndex:返回指定元素的最后一个index，如果没有返回-1

Log.i("Lbjfan lastIndexOf", list.lastIndexOf(2).toString())
1

运行结果：

09-06 00:50:04.561 16631-16631/com.example.admin.kotlindemo I/Lbjfan lastIndexOf: 1
1

lastOrNull:返回指定元素的最后一个Index,如果灭有返回null

Log.i("Lbjfan lastOrNull", list.lastOrNull { it % 2 == 0 }.toString())
1

运行结果：

09-06 00:50:04.562 16631-16631/com.example.admin.kotlindemo I/Lbjfan lastOrNull: 4
1

single:返回符合给定函数的单个元素，如果没有符合或者超过一个，则抛出异常

Log.i("Lbjfan single", list.single { it % 3 == 0 }.toString())
1

运行结果:

09-06 00:50:04.562 16631-16631/com.example.admin.kotlindemo I/Lbjfan single: 3
1

singleNull:返回符合给定函数的单个元素，如果没有或超过一个则返回null

Log.i("Lbjfan singleOrNull", list.singleOrNull { it % 6 == 0 }.toString())
1

运行结果：

09-06 00:50:04.562 16631-16631/com.example.admin.kotlindemo I/Lbjfan singleOrNull: null
1

5.顺序操作符

---

reversed:返回一个与指定list顺序相反的list

Log.i("Lbjfan reverse", list.reversed().toString())
1

运行结果:

09-06 01:15:28.667 7813-7813/com.example.admin.kotlindemo I/Lbjfan reverse: [5, 4, 3, 2, 1]
1

sort:返回一个自然排序后的list

Log.i("Lbjfan sort", list.sorted().toString())
1

运行结果：

09-06 01:15:28.667 7813-7813/com.example.admin.kotlindemo I/Lbjfan sort: [1, 2, 3, 4, 5]
1

sortBy:返回一个根据指定函数排序后的list

Log.i("Lbjfan sortBy", list.sortedBy { it % 2 }.toString())
1

运行结果：

09-06 01:15:28.670 7813-7813/com.example.admin.kotlindemo I/Lbjfan sortBy: [2, 4, 1, 3, 5]
1

sortDescending：返回一个降序排序后的list

Log.i("Lbjfan sortDescending", list.sortedDescending().toString())
1

运行结果：

09-06 01:15:28.670 7813-7813/com.example.admin.kotlindemo I/Lbjfan sortDescending: [5, 4, 3, 2, 1]
1

sortByDescending:返回一个根据指定函数降序排序后的list

Log.i("Lbjfan sortDescendingBy", list.sortedByDescending { it % 2 }.toString())
1

运行结果：

09-06 01:15:28.671 7813-7813/com.example.admin.kotlindemo I/Lbjfan sortDescendingBy: [1, 3, 5, 2, 4]
1

这里小白只是介绍和演示了Kotlin中一些集合操作符的常规使用，源码和使用过程中可能出现的问题并没有演示大家在学习的时候一定要动手去操作，发散问题!希望这篇文章对大家有所帮助！