函數式Android編程（II）：Kotlin語言的集合操作

原文標題：Functional Android (II): Collection operations in Kotlin

原文鏈接：http://antonioleiva.com/collection-operations-kotlin/

原文作者：Antonio Leiva（http://antonioleiva.com/about/）

原文發布：2015-09-29

 

在簡化代碼方面，Lambda表達式是一個傑出的工具，而且還可以完成之前不可能完成的事。我們在這個系列文章的第一篇（Unleash functional power on Android(I):Kotlin Lambdas [譯文]）中談論過它們。

 

最后，Lambda表達式是實現大量函數特性的基礎，如我們今天要討論的：集合操作。Kotlin提供了一組非常棒的操作，在不支持Lambda表達式的語言中，這些操作是不可能的（或是十分繁瑣）。

 

本文不是特別對Android的，但是，將以許多不同方法推動Android APP開發。今天，我將討論Kotlin提供的不同類型集合，以及能對這些集合進行的操作。

 

集合

 

雖然，我們可以只使用Java集合，然而Kotlin提供了一套你想要用的很好的本機接口:

 

• Iterable：父類。任何類繼承這個接口就表示可以遍歷序列的元素。
• MutableIterable：在迭代期間支持移除項目的迭代。
• Collection：這個類表示元素的泛型集合。我們可以訪問函數：返回集合尺寸、集合是否為空、包含一項或一組。由於集合是不可變的，這類集合的所有方法只能請求數據。
• MutableCollection：支持添加和移除元素的Collection。它提供額外的函數，如：add、remove或clear等等。
• List：或許這是最常用的集合。這表示有序的元素泛型集合。由於是有序的，我們可以用get函數，按照項目的位置請求項目。
• MutableList：支持添加和移除元素的List。
• Set：不支持重復元素的無序元素集合。
• MutableSet：支持添加和移除元素的Set。
• Map：key-value（鍵-值）對集合。在映射表（map）中key（鍵）是唯一的，就是說在一個映射表中不能有兩對有相同的key。
• MutableMap：支持添加和移除元素的Map。

 

集合操作

 

這組函數操作可以用於不同的集合。我要給大家展示一些定義和例子。掌握這些選項是很有用的，這樣可以容易地確定怎樣使用這些函數。如果有遺漏標准函數庫中任何函數請告知我。

 

所有這些以及更詳細的內容都可以在《Android開發者的Kotlin》書中找到。

 

18.1 聚合操作

any

如果至少有一個元素與指定條件相符，則返回true。

val list = listOf(1, 2, 3, 4, 5, 6)
assertTrue(list.any { it % 2 == 0 })
assertFalse(list.any { it > 10 })

 

all

如果所有元素與指定條件相符，則返回true。

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

 

count

返回與指定條件相符的元素個數。

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

 

fold

將對集合從第一個到最后一個元素的操作結果進行累加，並加上初始值。

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

 

foldRight

同fold，但是，是從最后一個元素到第一個元素。

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

 

forEach

對每個元素執行指定的操作。

list forEach { println(it) }

 

forEachIndexed

同forEach，不過同時還獲得元素的索引。

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

 

max

返回最大元素。如果沒有元素，則返回null。

assertEquals(6, list.max())

 

maxBy

返回使指定函數產生最大值的第一個元素。如果沒有元素，則返回null。

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

 

min

返回最小元素，如果沒有元素，則返回null。

assertEquals(1, list.min())

 

minBy

返回使指定函數產生最小值的第一個元素。如果沒有元素，則返回null。

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

 

none

如果沒有元素與指定條件相符，則返回true。

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

 

reduce

同fold，但是不包括初始值。只是將對集合從第一個元素到最后一個元素的操作結果進行累加。

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

 

reduceRight

同reduce，但是，是從最后一個元素到第一個元素。

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

 

sumBy

返回集合中元素進轉換函數產生值的總和。

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

 

18.2 篩選操作

drop

返回所有元素列表，但不包括前N個元素。

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

 

dropWhile

返回所有元素列表，但不包括第一個滿足指定條件的元素。

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

 

dropLastWhile

返回所有元素列表，但不包括滿足指定條件的最后一個元素。

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

 

filter

返回所有與指定條件相符的元素列表。

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

 

filterNot

返回與指定條件不符的所有元素列表。

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

 

filterNotNull

返回所有元素列表，但不包括null元素。

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

 

slice

返回指定索引的元素列表。

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

 

take

返回前N個元素列表。

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

 

takeLast

返回最后N個元素列表。

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

 

takeWhile

返回滿足指定條件第一個元素列表。

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

 

18.3 映射操作

flatMap

通過遍歷每個元素創建一個新集合，最后，把所有集合整合到包含所有元素的唯一列表中。

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

 

groupBy

返回一個映射表，該表包括經指定函數對原始集合中元素進行分組后的元素。

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

 

map

返回一個列表，該列表包含對原始集合中每個元素進行轉換后結果。

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

 

mapIndexed

返回一個列表，該列表包含對原始集合中每個元素進行轉換后結果和它們的索引。

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

 

mapNotNull

返回一個列表，該列表包含對原始集合中非null元素轉換后的結果。

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

 

18.4 元素操作

contains

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

assertTrue(list.contains(2))

 

elementAt

返回指定索引位置的元素。如果索引超出這個集合的范圍，則拋出IndexOutOfBoundsException。

assertEquals(2, list.elementAt(1))

 

elementAtOrElse

返回指定索引位置的元素。如果索引超出這個集合的范圍，則返回調用默認函數的結果。

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

 

elementAtOrNull

返回索引位置的元素。如果索引超出這個集合的范圍，則返回null。

assertNull(list.elementAtOrNull(10))

 

first

返回與指定條件相符的第一個元素。

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

 

firstOrNull

返回與指定條件相符的第一個元素。如果沒有找到相符的元素，則返回null。

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

 

indexOf

返回第一個元素的索引。如何集合沒有包含元素，則返回-1。

assertEquals(3, list.indexOf(4))

 

indexOfFirst

返回第一個與指定條件相符的元素索引。如果集合沒有包含這樣的元素，則返回 -1。

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

 

indexOfLast

返回最后一個與指定條件相符的元素索引。如果集合沒有包含這樣的元素，則返回 -1。

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

 

last

返回與指定條件相符的最后一個元素。

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

 

lastIndexOf

返回最后一個元素索引。如果集合沒有包含元素，則返回 -1。

val listRepeated = listOf(2, 2, 3, 4, 5, 5, 6)
assertEquals(5, listRepeated.lastIndexOf(5))

 

lastOrNull

返回與指定條件相符的最后一個元素。如果沒有找到這樣的元素，則返回null。

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

 

single

返回與指定條件相符的單一元素。如果沒有或有多個相符的元素，則拋出異常。

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

 

singleOrNull

返回與指定條件相符的單一元素。如果沒有找到這樣元素或有找到多個這樣元素，則返回null。

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

 

18.5 生成操作

merge

返回一個列表，該列表由兩個集合中有相同索引元素經轉換函數轉換而組成的。這個列表的長度是最大集合的長度。

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

 

partition

將原始集合拆分一對集合，一個集合包含判斷條件為true的元素，另一個集合包含判斷條件為false的元素。

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

 

plus

返回一個列表，該列表包含原始集合的所有元素和指定集合的所有元素。由於函數名稱原因，我們可以使用“+”操作符。

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

 

zip

返回一個列表，該列表由兩個集合中相同索引元素建立的元素對。這個列表長度為最短集合的長度。

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

 

18.6 排序操作

reverse

返回逆序元素列表。

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

 

sort

返回所有元素分類排序列表。

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

 

sortBy

返回所有元素列表，其元素通過特定的比較器分類排序。

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

 

sortDescending

返回所有元素分類排序列表，其順序為降序。

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

 

sortDescendingBy

返回所有元素的分類排序列表，其順序為通過特定排序函數結果的降序。

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

 

 

 

前一篇：http://www.cnblogs.com/figozhg/p/5021725.html