Kotlin学习日记（九）集合和函数操作符

这个直接复制kotlin-for-android-developers-zh里面的内容了。

集合和函数操作符

Kotlin也提供了一些你希望用的本地的接口：

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

不同集合可用的函数操作符，可以通过例子来知道有哪些可选的操作符是很有用的，这样会更容易分辨它们使用的时机。 

我们以集合val list = listOf(1, 2, 3, 4, 5, 6)为例进行一些操作：

—总数操作符——- 

1.any 

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

assertTrue(list. any { it % 2 == 0 })assertFalse(list. any { it > 10 })

2.all 

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

assertTrue(list.all { it < 10 })assertFalse(list.all { it % 2 == 0 })

3.count 

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

assertEquals( 3 , list.count { it % 2 == 0 })

4.fold 

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

assertEquals( 25 , list.fold( 4 ) { total, next -> total + next })

5.foldRight 

与fold一样，但是顺序是从最后一项到第一项。

assertEquals( 25 , list.foldRight( 4 ) { total, next -> total + next })

6.forEach 

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

list . forEach { println(it) }

7.forEachIndexed 

与forEach，但是我们同时可以得到元素的index。

list.forEachIndexed { index , value -> println( "position $index contains a $value " ) }

8.max 

返回最大的一项，如果没有则返回null。

assertEquals( 6 , list.max())

9.maxBy 

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

// The element whose negative is greater assertEquals( 1 , list. maxBy { -it })

10.min 

返回最小的一项，如果没有则返回null。

assertEquals( 1 , list.min())

11.minBy 

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

// The element whose negative is smaller assertEquals( 6 , list. minBy { -it })

12.none 

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

// No elements are divisible by 7 assertTrue(list. none { it % 7 == 0 })

13.reduce 

与fold一样，但是没有一个初始值。通过一个函数从第一项到最后一项进行累计。

assertEquals( 21 , list.reduce { total, next -> total + next })

14.reduceRight 

与reduce一样，但是顺序是从最后一项到第一项。

assertEquals( 21 , list.reduceRight { total, next -> total + next })

15.sumBy 

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

assertEquals( 3 , list.sumBy { it % 2 })

—过滤操作符——- 

1.drop 

返回包含去掉前n个元素的所有元素的列表。

assertEquals(listOf( 5 , 6 ), list.drop( 4 ))

2.dropWhile 

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

assertEquals(listOf( 3 , 4 , 5 , 6 ), list.dropWhile { it < 3 })

3.dropLastWhile 

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

assertEquals(listOf( 1 , 2 , 3 , 4 ), list.dropLastWhile { it > 4 })

4.filter 

过滤所有符合给定函数条件的元素。

assertEquals(listOf( 2 , 4 , 6 ), list .ilter { it % 2 == 0 })

5.filterNot 

过滤所有不符合给定函数条件的元素。

assertEquals(listOf( 1 , 3 , 5 ), list.filterNot { it % 2 == 0 })

6.filterNotNull 

过滤所有元素中不是null的元素。

assertEquals(listOf( 1 , 2 , 3 , 4 ), listWithNull.filterNotNull())

7.slice 

过滤一个list中指定index的元素。

assertEquals(listOf( 2 , 4 , 5 ), list.slice(listOf( 1 , 3 , 4 )))

8.take 

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

assertEquals(listOf( 1 , 2 ), list.take( 2 ))

9.takeLast 

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

assertEquals(listOf( 5 , 6 ), list.takeLast( 2 ))

10.takeWhile 

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

assertEquals(listOf( 1 , 2 ), list.takeWhile { it < 3 })

–映射操作符——–

1.flatMap 

遍历所有的元素，为每一个创建一个集合，最后把所有的集合放在一个集合中。

assertEquals(listOf( 1 , 2 , 2 , 3 , 3 , 4 , 4 , 5 , 5 , 6 , 6 , 7 ), list.flatMap { listOf(it, it + 1 ) })

2.groupBy 

返回一个根据给定函数分组后的map。

assertEquals(mapOf( "odd" to listOf( 1 , 3 , 5 ), "even" to listOf( 2 , 4 , 6 )), list.groupBy { if ( it % 2 == 0 ) "even" else "odd" })

3.map 

返回一个每一个元素根据给定的函数转换所组成的List。

assertEquals(listOf( 2 , 4 , 6 , 8 , 10 , 12 ), list.map { it * 2 })

4.mapIndexed 

返回一个每一个元素根据给定的包含元素index的函数转换所组成的List。

assertEquals(listOf ( 0 , 2 , 6 , 12 , 20 , 30 ), list.mapIndexed { index, it -> index * it })

5.mapNotNull 

返回一个每一个非null元素根据给定的函数转换所组成的List。

assertEquals(listOf( 2 , 4 , 6 , 8 ), listWithNull.mapNotNull { it * 2 })

–元素操作符——– 

1.contains 

如果指定元素可以在集合中找到，则返回true。

assertTrue(list.contains( 2 ))

2.elementAt 

返回给定index对应的元素，如果index数组越界则会抛出IndexOutOfBoundsException。

assertEquals( 2 , list.elementAt( 1 ))

3elementAtOrElse 

返回给定index对应的元素，如果index数组越界则会根据给定函数返回默认值。

assertEquals( 20 , list.elementAtOrElse( 10 , { 2 * it }))

4.elementAtOrNull 

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

assertNull(list.elementAtOrNull( 10 ))

5.first 

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

assertEquals( 2 , list. first { it % 2 == 0 })

6.firstOrNull 

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

assertNull(list.firstOrNull { it % 7 == 0 })

7.indexOf 

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

assertEquals( 3 , list.indexOf( 4 ))

8.indexOfFirst 

返回第一个符合给定函数条件的元素的index，如果没有符合则返回-1。

assertEquals( 1 , list.indexOfFirst { it % 2 == 0 })

9.indexOfLast 

返回最后一个符合给定函数条件的元素的index，如果没有符合则返回-1。

assertEquals( 5 , list.indexOfLast { it % 2 == 0 })

10.last 

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

assertEquals( 6 , list. last { it % 2 == 0 })

11.lastIndexOf 

返回指定元素的最后一个index，如果不存在，则返回-1。 

12.lastOrNull 

返回符合给定函数条件的最后一个元素，如果没有符合则返回null。

val list = listOf( 1 , 2 , 3 , 4 , 5 , 6 )assertNull( list .lastOrNull { it % 7 == 0 })

13single 

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

assertEquals( 5 , list.single { it % 5 == 0 })

14.singleOrNull 

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

assertNull(list.singleOrNull { it % 7 == 0 })

–生产操作符——– 

1.merge 

把两个集合合并成一个新的，相同index的元素通过给定的函数进行合并成新的元素作为新的集合的一个元素，返回这个新的集合。新的集合的大小由最小的那个集合大小决定。

val list = listOf( 1 , 2 , 3 , 4 , 5 , 6 ) val listRepeated = listOf( 2 , 2 , 3 , 4 , 5 , 5 , 6 )assertEquals(listOf( 3 , 4 , 6 , 8 , 10 , 11 ), list .merge(listRepeated) { it1, it2 -> it1 + it2 })

2.partition 

把一个给定的集合分割成两个，第一个集合是由原集合每一项元素匹配给定函数条件返回true的元素组成，第二个集合是由原集合每一项元素匹配给定函数条件返回false的元素组成。

assertEquals( Pair(listOf( 2 , 4 , 6 ), listOf( 1 , 3 , 5 )), list.partition { it % 2 == 0 })

3.plus 

返回一个包含原集合和给定集合中所有元素的集合，因为函数的名字原因，我们可以使用+操作符。

assertEquals( listOf( 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 ), list + listOf( 7 , 8 ))

4.zip 

返回由pair组成的List，每个pair由两个集合中相同index的元素组成。这个返回的List的大小由最小的那个集合决定。

assertEquals( listOf(Pair( 1 , 7 ), Pair( 2 , 8 )), list.zip(listOf( 7 , 8 )))

5.unzip 

从包含pair的List中生成包含List的Pair。

assertEquals( Pair(listOf( 5 , 6 ), listOf( 7 , 8 )), listOf(Pair( 5 , 7 ), Pair( 6 , 8 )).unzip())

–顺序操作符——– 

1.reverse 

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

val unsortedList = listOf(3, 2, 7, 5)assertEquals(listOf(5, 7, 2, 3), unsortedList.reverse())

2.sort 

返回一个自然排序后的list。

assertEquals(listOf( 2 , 3 , 5 , 7 ), unsortedList.sort())

3.sortBy 

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

assertEquals(listOf( 3 , 7 , 2 , 5 ), unsortedList.sortBy { it % 3 })

4.sortDescending 

返回一个降序排序后的List。

assertEquals(listOf( 7 , 5 , 3 , 2 ), unsortedList.sortDescending())

5.sortDescendingBy 

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

assertEquals(listOf( 2 , 5 , 7 , 3 ), unsortedList.sortDescendingBy { it % 3 })

Map类的拓展实现

for（（key，value）in map）{

Log.d（"map","key : $key, value : $value"）;

}