初識Kotlin之集合

ITDragon龍發表於2019-05-18
Kotlin

Kotlin的集合是讓我為之心動的地方，豐富的高階函式幫助我們高效開發。今天介紹Kotlin的基礎集合用法、獲取集合元素的函式、過濾元素的函式、元素排序的函式、元素統計的函式、集合元素對映的函式、集合的交差並補集的函式。還有一些工作中的經驗。

初始化集合

和Java集合不同的是，Kotlin的集合分可變和不可變兩種集合。同時也支援兩種集合相互切換。

List集合

// 宣告並初始化不可變List集合
val list: List<Any> = listOf<Any>(1, "2", 3)
// 宣告並初始化可變MutableList集合
val mutableList: MutableList<Any> = mutableListOf<Any>(4, "5", 6)
mutableList.add("7")
list.map { print("$it \t") }
mutableList.map { print("$it \t") }

Set集合

// 宣告並初始化不可變Set集合
val set: Set<Any> = setOf<Any>(1, "2", 3, "3")
// 宣告並初始化可變MutableSet集合
val mutableSet: MutableSet<Any> = mutableSetOf<Any>(4, "5", 6)
mutableSet.add(6)
set.map { print("$it \t") }
mutableSet.map { print("$it \t") }

Map集合

// 宣告並初始化不可變Map集合
val map: Map<String, Any> = mapOf("k1" to "v1" , "k2" to 3)
// 宣告並初始化可變MutableMap集合
val mutableMap: MutableMap<String, Any> = mutableMapOf("k1" to "v1" , "k1" to 3)
map.map { println("key : ${it.key} \t value : ${it.value}") }
mutableMap.map { println("key : ${it.key} \t value : ${it.value}") }

集合高階函式

獲取集合元素

用Java語言開發時，我們通常用迴圈遍歷集合的每個元素。有時候也會通過下標直接獲取指定元素。此時原則上時需要我們先考慮集合元素的長度，以避免下標越界的異常問題。但往往我們會抱著僥倖的心態直接通過get(index)方法獲取元素。一般情況下我們會在黑盒自測中發現越界問題（有部分朋友從不黑盒，直接白盒測試，並反問：測試的工作難道不就是發現問題？）。即便是在執行中出現越界問題，也可以甩鍋給資料庫。但不管怎麼樣，因為越界導致系統不穩定是不合理的。

用Kotlin語言開發時，我們會發現有很多帶有"Or"字樣的方法。比如我常用的getOrElse，firstOrNull 等方法。分別表示：通過下標如果沒有獲取到值，則返回自定的值。和獲取集合的第一個元素，若集合為空則返回null。正因為Kotlin提供了很多類似getOrElse，firstOrNull 的方法。很大程度上提高了我們的開發效率，和減少了一些低階錯誤發生的概率。接下來我們學習一下Kotlin具體有哪些獲取集合元素的方法（single方法沒怎麼用過）

常用函式

  • get(index) : List的函式，通過下標獲取指定元素。若找不到值（下標越界），會丟擲IndexOutOfBoundsException異常
  • getOrElse(index, {...}) : List的擴充套件函式，通過下標獲取指定元素。找不到值則返回預設值
  • getOrNull(index) : List的擴充套件函式，通過下標獲取指定元素。找不到值則返回null
  • elementAtOrElse(index, {...}) : Iterable介面的擴充套件函式，功能同getOrElse 方法
  • elementAtOrNull(index) : Iterable介面的擴充套件函式，功能同getOrNull 方法
  • 注意get方法是List獨有，其他集合可以用element方法。
  • first() : 獲取集合第一個元素。若沒有返回值，則丟擲NoSuchElementException異常
  • first{} : 獲取集合中指定元素的第一個元素。若沒有返回值，則丟擲NoSuchElementException異常
  • firstOrNull() : 獲取集合第一個元素。若沒有返回值，返回null
  • firstOrNull{} : 獲取集合指定元素的第一個元素。若沒有返回值，返回null
  • 看到這裡，是不是有點明白Kotlin獲取元素的規則：如果沒有則怎麼樣
  • last() : 與first()相反
  • last{} : 與first{}相反
  • lastOrNull{} : 與firstOrNull()相反
  • lastOrNull() : 與firstOrNull{}相反
  • indexOfFirst{...} : 返回集合中第一個滿足條件元素的下標
  • indexOfLast{...} : 返回集合中最後一個滿足條件元素的下標
  • 咋也不知道single方法設計的初衷，咋也不敢問
  • single() : Returns the single element, or throws an exception if the collection is empty or has more than one element. 官方api文件地址
  • single{} : 按照條件返回單個元素，若集合為空或者有多個元素滿足條件，則報錯
  • singleOrNull() : 返回單個元素，若集合為空或者有多個元素，則返回null
  • singleOrNull{} : 按照條件返回單個元素，若集合為空或者有多個元素滿足條件，則返回null

使用建議

在使用獲取元素的方法時，推薦方法名中帶有"Or"字樣的方法，可以減少很多不必要的報錯。

List集合通過下標獲取元素可以用get,getOrElse,getOrNull函式，但其他集合沒有這些方法。

筆者單方面認為single函式和資料庫的唯一約束的功能有點類似，在使用Kotlin的過程中，你會發現它有很多和資料庫類似的功能。

基礎用法

val list: MutableList<Int> = mutableListOf(1,2,3,4,5)
println("getOrElse : ${list.getOrElse(10,{ 20 })}")
println("getOrNull : ${list.getOrNull(10)}")
println("firstOrNull : ${list.firstOrNull()}")
println("firstOrNull : ${list.firstOrNull { it > 3 }}")
println("indexOfFirst : ${list.indexOfFirst { it > 3 }}")
println("indexOfLast : ${list.indexOfLast { it > 3 }}")
-----------------------------------------------------
getOrElse : 20
getOrNull : null
firstOrNull : 1
firstOrNull : 4
indexOfFirst : 3
indexOfLast : 4

集合元素排序

用Java語言開發時，給物件集合做排序是常有的業務邏輯。（Java8之後的寫法不太瞭解）按照我之前工作中排序的程式碼其實也並不複雜，十行程式碼基本可以搞定一個排序邏輯。注意是一個，一個。業務中存在大量的排序需求，這種程式碼會反覆出現。對於我這種佛系程式設計師兼CV高手而言，早已經習以為常了。但自從用了Kotlin的sortedBy方法後。突然覺得Kotlin用起來倍兒爽！

用Java7開發了幾年，Java8只接觸了一點皮毛，現在Java12都已經出來了。經常看到一些文章為了突出某個語言的強大，而去踩其他語言。我只想問：who are you？每個語言都有自己獨特的一面.神仙打架，我們負責吃瓜就好。就懂點皮毛的人，瞎摻和啥？

Collections.sort(list,new Comparator () {
    @Override
    public int compare(Object o1, Object o2) {
        return o1.compareTo(e2);
    }
});

用Kotlin語言開發時，我們不需要重複寫類似上面的排序程式碼，Kotlin已經幫我們封裝好了，只需要我們寫需要排序的欄位即可。其底層也是通過Java 的Collections.sort實現的。所有我們就放心大膽的用吧。

public inline fun <T, R : Comparable<R>> MutableList<T>.sortBy(crossinline selector: (T) -> R?): Unit {
    if (size > 1) sortWith(compareBy(selector))
}

@kotlin.jvm.JvmVersion
public fun <T> MutableList<T>.sortWith(comparator: Comparator<in T>): Unit {
    if (size > 1) java.util.Collections.sort(this, comparator)
}

常用函式

  • sortedBy{} : 根據條件給集合升序，常用與給物件集合的某個欄位排序，並返回排序後的集合，原集合順序不變
  • reversed() : 集合反序。與降序不同，反序指的是和初始化的順序相反
  • sorted() : 自然升序，常用於給普通集合排序
  • sortedDescending() : 自然降序
  • sortedByDescending{} : 根據條件給集合降序
  • ed結尾的排序方法，是不會對原集合進行修改，而是返回一個排序後的新集合。沒有以ed結尾的方法恰恰相反 ---來自一個不嚴謹的總結
  • sortBy{} : 根據條件給原集合升序，常用與給物件集合的某個欄位排序
  • sortByDescending{} : 根據條件給原集合降序
  • reverse() : 原集合反序

使用建議

千萬不要把反序理解成了倒序，前車之鑑

sortBy方法是對原集合做排序操作，而sortedBy方法是返回一個排序後的新集合，原集合排序沒有變

kotlin排序方法中可以用and，or 組裝多個條件，但效果並不理想

基礎用法

data class Person(
    var name: String = "",
    var age: Int = 0,
    var salary: Double = 0.0
)

val persons = mutableListOf(Person("n1", 20, 2000.0),
    Person("n2", 24, 4000.0),
    Person("n3", 28, 6000.0),
    Person("n4", 26, 8000.0),
    Person("n5", 34, 7000.0),
    Person("n6", 44, 5000.0))
persons.sortedBy { it.age }.map { println(it) }
persons.map { it.age }.sorted()
persons.sortBy { it.age }
persons.reversed()

過濾元素

Java8也提供了Map和Filter函式用於轉換和過濾物件，使開發變得更輕鬆，遙想當年在for迴圈裡面加if語句。慢慢成了過去式。集合遍歷之前先filter一下，已經成了我開發過程中不可或缺的一步。雖然 filter 函式相對於Kotlin的 getOrNull 和 sortedBy 函式，並沒有給人一種眼前一亮的感覺。但它提高了程式碼的可讀性和美觀性。

常用函式

  • filter{...} : 過濾不滿足條件的元素，返回只滿足條件元素列表，不影響原集合
  • filterNot{...} : 和filter{}函式的功能相反
  • filterNotNull() : 過濾掉集合中為null的元素
  • filterIndexed{...} : 在filter{}函式上多了一個下標功能，可以通過索引進一步過濾
  • Kotlin的函式是見名知意，非常好用，上手也快，弄明白一個方法，其他方法都沒大的問題
  • distinct() : 去除重複元素，返回元素的順序和原集合順序一致
  • distinctBy{...} : 根據操作元素後的結果去去重，去除的是操作前的元素
  • take(num) : 返回集合中前num個元素組成的集合
  • takeWhile{...} : 從第一個元素開始遍歷集合，當出現第一個不滿足條件元素時退出迴圈。返回所有滿足條件的元素集合
  • takeLast(num) : 和take 函式相反，返回集合中後num個元素組成的集合
  • takeLastWhile{...} : 從最後一個元素開始遍歷集合，當出現第一個不滿足條件元素時退出迴圈。返回所有滿足條件的元素集合
  • 不要被這麼多方法嚇到，學了take函式的用法，takeLast、drop、dropLast的用法都可以猜到
  • drop(num) : 過濾集合中前num個元素
  • dropWhile{...} : 和執行takeWhile{...}函式後得到的結果相反
  • dropLast(num) : 過濾集合中後num個元素
  • dropLastWhile{...} : 和執行takeLastWhile{...}函式後得到的結果相反
  • slice(...) : 過濾掉所有不滿足執行下標的元素。引數是下標集合或者是下標區間。

使用建議

以上Filter、Distinct、Take、Drop、Slice方法都返回一個處理後的新集合，不影響原集合。

Kotlin提供了豐富的函式供我們使用，同時也嚇退了很多朋友，別怕！Kotlin的函式都是買一送一的，學會一個，不愁另一個。

基礎用法

val list = listOf(-3,-2,1,3,5,3,7,2,10,9)
println("filter : ${list.filter { it > 1 }}")
println("filterIndexed : ${list.filterIndexed { index, result ->
        index % 2 == 0 && result > 5
        }}")
println("take : ${list.take(5)}")
println("takeWhile : ${list.takeWhile { it < 5 }}")
println("drop : ${list.drop(5)}")
println("distinct : ${list.distinct()}")
println("distinctBy : ${list.distinctBy { it % 2 }}")
println("slice : ${list.slice(IntRange(1,5))}")
-----------------------------------------------------
filter : [3, 5, 3, 7, 2, 10, 9]
filterIndexed : [7, 10]
take : [-3, -2, 1, 3, 5]
takeWhile : [-3, -2, 1, 3]
drop : [3, 7, 2, 10, 9]
distinct : [-3, -2, 1, 3, 5, 7, 2, 10, 9]
distinctBy : [-3, -2, 1]
slice : [-2, 1, 3, 5, 3]

統計元素

在用Java8和Kotlin之前。和排序一樣，在實現求最大值、平均值、求和等操作時，都要寫很多冗餘的程式碼。現在好了，Kotlin已經封裝了這些方法。朋友們，千萬不要過於依賴這些方法。有些一條sql能解決的問題，就不要把統計的邏輯留給程式碼完成。這裡的方法更適合在業務處理過程中，對一些簡單集合的統計處理。如果是統計報表的功能，就不要有什麼歪心思了。分享一篇關於統計的文章：常見的統計解決方案

常用函式

  • max() : 獲取集合中最大的元素，若為空元素集合，則返回null
  • maxBy{...} : 獲取方法處理後返回結果最大值對應那個元素的初始值，如果沒有則返回null
  • min() : 獲取集合中最小的元素，若為空元素集合，則返回null
  • minBy{...} : 獲取方法處理後返回結果最小值對應那個元素的初始值，如果沒有則返回null
  • sum() : 對集合原元素資料進行累加，返回值型別是Int
  • sumBy{...} : 根據元素運算操作後的結果進行累加，返回值型別是Int
  • sumByDouble{...} : 和sumBy{}相似，但返回值型別是Double
  • average() : 對集合求平均數
  • reduce{...} : 從集合中的第一個元素到最後一個元素的累計操作
  • reduceIndexed{...} : 在reduce{}函式基礎上多了一個下標功能
  • reduceRight{...} : 與reduce{...} 相反，該方法是從最後一個元素開始
  • reduceRightIndexed{...} : 在reduceRight{}函式基礎上多了一個下標功能
  • fold{...} : 和reduce{}類似，但是fold{}有一個初始值
  • foldIndexed{...} : 和reduceIndexed{}類似，但是foldIndexed{}有一個初始值
  • foldRight{...} : 和reduceRight{}類似，但是foldRight{}有一個初始值
  • foldRightIndexed{...} : 和reduceRightIndexed{}類似，但是foldRightIndexed{}有一個初始值
  • any{...} : 判斷集合中是否存在滿足條件的元素
  • all{...} : 判斷集合中的所有元素是否都滿足條件
  • none{...} : 和all{...}函式的作用相反

使用建議

不能過於依賴Kotlin的統計方法，這些方法更適合一些業務邏輯上的簡單統計處理，不適合資料統計功能。

注意sum函式返回結果是Int型別，如果是Double則需要用sumByDouble方法。

基礎用法

val persons = mutableListOf(Person("n1", 20, 2000.0),
    Person("n2", 24, 4000.0),
    Person("n3", 28, 6000.0),
    Person("n4", 26, 8000.0),
    Person("n5", 34, 7000.0),
    Person("n6", 44, 5000.0))
println("maxBy : ${persons.maxBy { it.age }}")
println("sumByDouble : ${persons.sumByDouble { it.salary }}")
println("average : ${persons.map { it.salary }.average()}")
println("any : ${persons.any { it.salary < 1000 }}")
-----------------------------------------------------
maxBy : Person(name=n6, age=44, salary=5000.0)
sumByDouble : 32000.0
average : 5333.333333333333
any : false

元素對映

Kotlin提供了一個遍歷集合的forEach方法，也提供了對集合每個元素都進行指定操作並返回一個新集合的map方法。map方法是可以遍歷集合，但如果誤將其認為遍歷集合的方法，同樣會將mapNotNull方法誤以為成遍歷非null元素的方法。

常用方法

  • map{...} : 把每個元素按照特定的方法進行轉換，並返回一個新的集合
  • mapNotNull{...} : 同map{}相同，過濾掉轉換之後為null的元素
  • mapIndexed{index,result} : 在map{} 函式上多了一個下標功能
  • mapIndexedNotNull{index,result} : 在mapNotNull{}函式上多了一個下標功能
  • flatMap{...} : 根據條件合併兩個集合，組成一個新的集合
  • groupBy{...} : 分組。即根據條件把集合拆分為為一個Map<K,List<T>>型別的集合

使用建議

map方法不是集合遍歷，集合遍歷的方法是forEach。

mapNotNull方法不是遍歷集合不為null的方法，而是過濾轉換後為null的元素。

呼叫string.split()函式，無論用forEach還是map，即使沒有內容還是會遍歷一次。

基礎用法

val list = listOf(-3,-2,1,3,5,3,7,2,10,9)
list.map { it + 1 }.forEach { print("$it \t") }
list.mapIndexedNotNull { index, value ->
       if (index % 2 == 0) value else null
}.forEach { print("$it \t") }
println("flatMap : ${list.flatMap { listOf(it, it + 1,"n$it") }}")
println("groupBy : ${list.groupBy { if (it % 2 == 0) "偶數" else "奇數" }}")

集合的交差並補操作

對集合的求交差集是一個常用的方法。比如前端需要將更新，建立，刪除的邏輯用一個介面完成。我們可以通過舊資料與新資料求差集找出需要刪除的資料。通過新資料和舊資料求差集找出需要建立的資料。通過求交集找出需要更新的資料。

  • intersect(...) : 返回一個集合，其中包含此集合和指定集合所包含的所有元素，交集
  • subtract(...) : 返回一個集合，其中包含此陣列包含但未包含在指定集合中的所有元素，差集
  • union(...) : 返回包含兩個集合中所有不同元素的集合，並集
  • minus(...) : 返回包含原始集合的所有元素的列表，但給定的陣列中包含的元素除外，補集

基礎用法

val list1 = mutableListOf(1,2,3,4,5)
val list2 = mutableListOf(4,5,6,7)
println("intersect : ${list1.intersect(list2)}")
println("subtract : ${list1.subtract(list2)}")
println("union : ${list1.union(list2)}")
println("minus : ${list1.minus(list2)}")
-----------------------------------------------------
intersect : [4, 5]
subtract : [1, 2, 3]
union : [1, 2, 3, 4, 5, 6, 7]
minus : [1, 2, 3]

官網地址：https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/

到這裡文章就結束了。如果用好集合的高階函式，可以讓我們的開發效率有明顯的提高，bug的數量也會銳減。文章還有一部分內容沒有介紹。我在工作用中集合就用MutableList、MutableSet、MutableMap，可Java中還有ArrayList，LinkedList，HashMap，HashSet等集合Kotlin中也有這些。一直都沒有好好研究，這個坑先挖好，後來再補上。

相關文章