Kotlin開發Android筆記12：集合和函數操作符

學習《Kotlin for Android Developers》中文翻譯也有一些日子了，但是中途因為項目忙，有幾天也沒有時間進行持續學習。

感覺學得少忘得多，越往後看越覺得復雜。這一系列筆記相當於就是把這本書給抄襲了一遍，真正學習到肚子裡的東西還是太少。

今天學習集合和函數操作符。Kotlin中的集合真是強大，提供了N多實用的方法，讓我們來看看吧。

比如，如果過濾一個list，不用去創建一個list，遍歷這個list的每一項，然後如果滿足一定的條件則放到一個新的集合中。

而是直接食用filer函數並指明我想用的過濾器。用這種方式，我們可以節省大量的代碼。

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 })

博客學習來自《《Kotlin for Android Developers》中文翻譯》。
相關代碼可以查看：https://github.com/antoniolg/Kotlin-for-Android-Developers
學習交流：https://github.com/ldm520/Android_Kotlin_Demo