淺談Kotlin中集合和函數式API徹底解析-上篇(八)

時間 2019-11-06

原文原文鏈接

簡述: 今天帶來的是Kotlin淺談系列的第八講，這講咱們一塊兒來聊聊Kotlin這門語言對函數式編程的支持。咱們都知道在kotlin這門語言中函數榮升成爲了一等公民，因此在支持函數式編程的方面，Kotlin這門語言也是很是給力的，而且在Kotlin中語法也儘可能推薦接近函數式編程的風格。學過以及瞭解過函數式編程的小夥伴都知道函數式編程最吸引人的地方，莫過於它擁有豐富的函數式操做符，可使用一種全新的編程方式去操做集合數據。其中操做符最流行莫過於函數式中「三板斧」(過濾filter、映射map、摺疊foldLeft/化約reduce)。那麼小夥伴會提問了:java

一、那Kotlin語言中有這些操做符嗎？

答: 固然有，不只有這些並且還有不少很豐富的函數式操做符，僅從這方面來講Kotlin這門語言是函數式編程語言一點也不爲過。python

二、那今天是講函數式API嗎？

答: 沒錯，今天會對Kotlin中全部函數式操做符API作詳細的講解，包括基本使用、基本定義、實質原理三個方面來作介紹，力求作到徹底解析編程

三、有什麼小建議？

最後，一個小建議，因爲Kotlin中的函數式API有不少，有些也不是常用的，建議先將常用的操做符(我會作好標記)理解、掌握。其餘不經常使用的後續能夠返回來查找便可app

今天闡述的內容點很簡單，主要有如下三點：less

一、Kotlin中集合的詳細介紹和徹底解析
二、Kotlin中函數式API操做符的分類
三、Kotlin中函數式API操做符的詳解

1、Kotlin中集合的詳細介紹和徹底解析

在介紹函數式API操做符以前，有必要去了解一下這些操做符操做的對象集合。實際上，Kotlin語言中的集合和Java仍是有必定區別的。在Kotlin中集合主要分爲了兩個大類，一類是可變集合(具備訪問和修改權限)，另外一類是只讀集合(只具備訪問權限)(注意: 這裏不能說不可變集合，只能說是具備可讀權限，關於這個不可變和可讀討論以前博客有相關闡述)。Kotlin的集合設計與Java集合設計有一個很重要區別就是Kotlin把集合訪問接口和集合修改接口分開了。dom

一、Kotlin爲何把集合設計爲可變和只讀兩種？

關於這個問題，實際上以前的var和val的分離設計已經回答了一部分。Kotlin這門考慮到實際開發中方便和程序中數據發生的事情更容易讓人理解，因此纔有此設計。咱們設想一下這樣的場景，kotlin中定義一個函數，函數的參數是一個可變集合，以kotlin開發規則而言，傳遞一個可變集合做爲參數，實際上也在代表在該函數體內部涉及到修改集合操做。若是傳遞的是一個只讀集合做爲參數，那麼代表在該函數體內是不會涉及到修改集合操做，只容許訪問集合。看到如此的設計你是否已經愛上了這門語言，也就是這門語言在各個方面和開發細節上都是花了不少功夫的，力求作到任何一步都是讓開發者開發更簡單和更容易理解。編程語言

二、集合的分類

在kotlin.collections包中包含相應集合。主要包含Iterable(只讀迭代器)和MutableIterable(可變迭代器)、Collection和MutableCollection、List和MutableList、Set和MutableSet、Map和MutableMapide

三、可變集合與只讀集合之間的區別和聯繫（以Collection集合爲例）

Collection只讀集合與MutableCollectio可變集合區別:函數式編程

在Collection只具備訪問元素的方法，不具備相似add、remove、clear之類的方法，而在MutableCollection中則相比Collection多出了修改元素的方法。函數

Collection只讀集合與MutableCollectio可變集合聯繫:

MutableCollection其實是Collection集合接口的子接口，他們之間是繼承關係。

四、集合之間類的關係

經過Collection.kt文件中能夠了解到有這些集合Iterable(只讀迭代器)和MutableIterable(可變迭代器)、Collection和MutableCollection、List和MutableList、Set和MutableSet、Map和MutableMap。那麼它們之間的類關係圖是怎樣的。

Iterable和MutableIterable接口分別是隻讀和可變集合的父接口，Collection繼承Iterable而後List、Set接口繼承自Collection，Map接口比較特殊它是單獨的接口，而後MutableMap接口是繼承自Map.

五、Java中的集合與Kotlin中集合對應關係

咱們剛剛說到在Kotlin中集合的設計與Java不同，可是每個Kotlin的接口都是其對應的Java集合接口的一個實例，也就是在Kotlin中集合與Kotlin中的集合存在必定的對應關係。Java中的ArrayList類和HashSet類實際上Kotlin中的MutableList和MutableSet集合接口的實現類。把這種關係加上，上面的類關係圖能夠進一步完善。

六、集合的初始化

因爲在Kotlin中集合主要分爲了只讀集合和可變集合，那麼初始化只讀集合和可變集合的函數也不同。以List集合爲例，對於只讀集合初始化通常採用listOf()方法，對於可變集合初始化通常採用mutableListOf()或者直接建立ArrayList<E>，由於mutableListOf()內部實現也是也仍是採用建立ArrayList,這個ArrayList其實是Java中的java.util.ArrayList<E>，只不過在Kotlin中使用typealias(關於typealias的使用以前博客有過詳細介紹)取了別名而已。關於具體內容請參考這個類kotlin.collections.TypeAliasesKt實現

七、集合使用的注意事項

注意點一: 在代碼的任何地方都優先使用只讀集合，只在須要修改集合的狀況下才去使用可變集合

注意點二: 只讀集合不必定是不可變的，關於這個只讀和不可變相似於val的只讀和不可變原理。

注意點三: 不能把一個只讀類型的集合做爲參數傳遞給一個帶可變類型集合的函數。

2、Kotlin中函數式API操做符的分類

Kotlin中函數式API操做符有不少，函數式中「三板斧」必須有的，定義和用法也是不盡相同。與其雜亂的死記硬背，不如先從大致上給這些API操做符分類，而後針對每一類去分析、理解、掌握，分類的規則也是按照各個操做符的功能來分。Kotlin中函數式API操做符主要有如下幾大類。

一、篩選類操做符(Filtering operations):主要有如下操做符

slice

filter系列

drop系列

take系列
二、並集類操做符(Aggregate operations):主要有如下操做符

any、all、count、none

fold系列

forEach系列

max系列

min系列

reduce系列

sum系列
三、映射類操做符(Mapping operations):主要有如下操做符

flatMap系列

groupBy系列

map系列
四、元素類操做符(Element operations):主要有如下操做符

elementAt系列

first系列

find系列

indexOf系列

last系列

single系列
五、排序類操做符(Ordering operations):主要有如下操做符

reverse

sort系列
六、生成類操做符(Generation operations):主要有如下操做符

partition

plus系列

zip系列

3、篩選類函數式API的詳解(Filtering operations)

slice操做符

一、基本定義

slice操做符顧名思義是"切片"的意思，也就是它能夠取集合中一部分元素或者某個元素，最後也是組合成一個新的集合。它有兩個重載函數，一個傳入IntRange對象指定切片起始位置和終止位置，最後切出的是一個範圍的元素加入到新集合中。另外一個是傳入一個Iterable下標集合，也就會從指定下標分別切出對應的元素，最後放入到新集合中。

二、源碼定義

public fun <T> List<T>.slice(indices: IntRange): List<T> {
    if (indices.isEmpty()) return listOf()
    return this.subList(indices.start, indices.endInclusive + 1).toList()
}

public fun <T> List<T>.slice(indices: Iterable<Int>): List<T> {
    val size = indices.collectionSizeOrDefault(10)
    if (size == 0) return emptyList()
    val list = ArrayList<T>(size)
    for (index in indices) {
        list.add(get(index))
    }
    return list
}
複製代碼

三、源碼解析

首先，slice函數是List<T>的一個擴展函數，它有兩個重載函數，一個是接收IntRange對象，另外一個是接收元素下標的集合對象，最終函數是返回一個List<T>集合。接收IntRange對象的函數實現很簡單，主要是經過IntRange對象拿到對應的start,end位置，而後利用subList拿到子集合，最後返回這個子集合。接收元素下標的集合的函數，是內部建立一個新的集合對象，而後遍歷整個原集合把元素下標集合中的元素加入到新建立的集合中，最後返回這個新的集合對象。

四、原理圖解

五、使用場景

slice by IntRange通常使用場景: 用於切取一段下標範圍的子集合

slice by itertar index通常使用場景: 用於切取某個或者某些下標元素組成的集合

fun main(args: Array<String>) {
    val numberList = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)

    val newNumberList1 = numberList.slice(IntRange(3, 6))
    print("slice by IntRange: ")
    newNumberList1.forEach {
        print("$it ")
    }

    println()

    val newNumberList2 = numberList.slice(listOf(1, 3, 7))
    print("slice by iterator index: ")
    newNumberList2.forEach {
        print("$it ")
    }
}
複製代碼

filter和filterTo操做符

一、基本定義:

根據用戶定義的條件篩選集合中的數據，而且由此產生一個新的集合。這個新的集合是原集合的子集。

二、源碼定義:

public inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T> {
    return filterTo(ArrayList<T>(), predicate)
}

public inline fun <T, C : MutableCollection<in T>> Iterable<T>.filterTo(destination: C, predicate: (T) -> Boolean): C {
    for (element in this) if (predicate(element)) destination.add(element)
    return destination
}
複製代碼

三、源碼解析:

首先，從總體上能夠看出filter是一個Iterable<T>的擴展函數而且是一個內聯函數，該函數接收一個以接收T類型返回一個Boolean類型的lambda表達式predicate做爲參數，因此它仍是一個高階函數，返回一個List<T>集合

而後，看具體的內部實現是調用了另外一個函數filterTo，並傳入新建立的ArrayList<T>()可變集合對象，而後繼續把lambda表達式做爲參數傳遞到filterTo函數中，在filterTo函數去實現真正的過濾操做。傳入的lambda表達式predicate實際上就是外部調用者傳入的過濾條件，能夠看到在filterTo內部是利用一個for循環進行篩選判斷符合lambda表達式條件的，就添加到filter調用filterTo函數傳遞的參數ArrayList<T>新集合對象中，最後就是返回這個ArrayList<T>新集合對象。因此filter最後篩選出來的仍是一個集合。

四、原理圖解:

五、使用場景:

filter的操做符使用場景: 從一個集合篩選出符合條件的元素，並以一個新集合返回。

fun main(args: Array<String>) {
    val numberList = listOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    val newNumberList = numberList.filter { number ->
        number % 2 == 0//篩選出偶數
    }

    newNumberList.forEach { print("$it ")}
}

複製代碼

filterTo的操做符使用場景: 從多個集合篩選出符合條件的元素，並最終用一個集合進行收集從每一個集合篩選出的元素。

fun main(args: Array<String>) {
    val numberList1 = listOf(23, 65, 14, 57, 99, 123, 26, 15, 88, 37, 56)
    val numberList2 = listOf(13, 55, 24, 67, 93, 137, 216, 115, 828, 317, 16)
    val numberList3 = listOf(20, 45, 19, 7, 9, 3, 26, 5, 38, 75, 46)
    
    //須要注意一點的是，咱們從源碼看到filterTo第一個參數destination是一個可變集合類型，因此這裏使用的mutableListOf初始化
    val newNumberList = mutableListOf<Int>().apply {
        numberList1.filterTo(this) {
            it % 2 == 0
        }
        numberList2.filterTo(this) {
            it % 2 == 0
        }
        numberList3.filterTo(this) {
            it % 2 == 0
        }
    }

    print("從三個集合篩選出的偶數集合: ")
    newNumberList.forEach {
        print("$it ")
    }
}
複製代碼

filterIndexed和filterIndexedTo操做符

一、基本定義:

filterIndexed操做符定義和filter幾乎是同樣的。他們以前惟一的區別是filterIndexed篩選條件的lambda表達式多暴露一個參數那就是元素在集合中的index.也就是外部能夠拿到這個元素以及這個元素的index. 特別適合須要集合元素index參與篩選條件的case。

二、源碼定義:

public inline fun <T> Iterable<T>.filterIndexed(predicate: (index: Int, T) -> Boolean): List<T> {
    return filterIndexedTo(ArrayList<T>(), predicate)
}

public inline fun <T, C : MutableCollection<in T>> Iterable<T>.filterIndexedTo(destination: C, predicate: (index: Int, T) -> Boolean): C {
    forEachIndexed { index, element ->
        if (predicate(index, element)) destination.add(element)
    }
    return destination
}

public inline fun <T> Iterable<T>.forEachIndexed(action: (index: Int, T) -> Unit): Unit {
    var index = 0
    for (item in this) action(index++, item)
}

複製代碼

三、源碼解析:

首先，要了解filterIndexed實現原理還須要涉及兩個操做符: filterIndexedTo、forEachIndexed。從總體上能夠看出filterIndexed是一個Iterable<T>的擴展函數而且是一個內聯函數，該函數接收一個以接收Int類型和接收T類型兩個參數返回一個Boolean類型的lambda表達式predicate做爲參數，因此它仍是一個高階函數，返回一個List<T>集合。

而後，大部分實現的原理和filter相似，filterIndexedTo和filterIndexed相似，惟一能夠說下的就是index，index其實是forEachIndexed內部的一個迭代自增計數器，能夠在內部每次迭代，就會計數器就會自增一次,而且把這個index回調到外部。

四、使用場景:

fun main(args: Array<String>) {
    val numberList = listOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

    val newNumberList = numberList.filterIndexed { index, number ->
        index < 5 && number % 2 == 0 //篩選出集合中前五個元素中是偶數的數
    }

    newNumberList.forEach {
        print("$it ")
    }
}
複製代碼

filterIsInstance和filterIsInstanceTo操做符

一、基本定義

filterIsInstance操做符是filter操做符一個特定應用，從集合中篩選出instance某個特定類型元素並把該元素強轉成該類型，最後返回這些元素集合。

二、源碼定義

public inline fun <reified R> Iterable<*>.filterIsInstance(): List<@kotlin.internal.NoInfer R> {
    return filterIsInstanceTo(ArrayList<R>())
}

public inline fun <reified R, C : MutableCollection<in R>> Iterable<*>.filterIsInstanceTo(destination: C): C {
    for (element in this) if (element is R) destination.add(element)
    return destination
}
複製代碼

三、源碼解析

首先，filterIsInstance是一個擴展函數，它的主要實現是藉助於filterIsInstanceTo，經過外部傳入的R泛型，建立一個R泛型的ArrayList可變集合，用於收集原集合中instance R類型的元素.能夠看出在filterIsInstanceTo內部是遍歷集合而後利用is判斷屬於R類型的元素就加入到集合中，最後返回該集合。

四、使用場景

filterInstance使用場景: 適用於一個抽象類集合中還有多種子類型的元素，能夠很方便篩選對應子類型的元素，並組成一個集合返回。

filterInstanceTo使用場景: 基本做用和filterInstance一致，不過惟一的區別就是這個可變集合ArrayList<R>不是在內部建立，而是由外部建立，很是適合篩選多個集合的狀況。

下面看個例子，咱們來看下不使用filterInstance和使用filterInstance狀況對比。

沒有使用filterInstance，而是使用filter和map集合相結合。(當你不知道有filterInstance操做符，估計不少都是這種實現的)

abstract class Animal(var name: String, var age: Int){
    abstract fun eatFood(): String
}
class Bird(name: String, age: Int): Animal(name, age){
    override fun eatFood() = "bird eat worm"
}
class Cat(name: String, age: Int) : Animal(name, age) {
    override fun eatFood() = "Cat eat Fish"
}
class Dog(name: String, age: Int) : Animal(name, age) {
    override fun eatFood() = "dog eat bone"
}

fun main(args: Array<String>) {
    val animalList: List<Animal> = listOf(Bird(name = "Bird1", age = 12),
            Cat(name = "Cat1", age = 18),
            Cat(name = "Cat3", age = 20),
            Dog(name = "Dog2", age = 8),
            Cat(name = "Cat2", age = 8),
            Bird(name = "Bird2", age = 14),
            Bird(name = "Bird3", age = 16),
            Dog(name = "Dog1", age = 18)
    )

    //篩選出個全部Dog的信息，藉助filter和map操做符
    animalList.filter {
        it is Dog
    }.map {
        it as Dog
    }.forEach {
        println("${it.name} is ${it.age} years old, and ${it.eatFood()}")
    }
}
複製代碼

使用filterInstance操做符實現

fun main(args: Array<String>) {
    val animalList: List<Animal> = listOf(Bird(name = "Bird1", age = 12),
            Cat(name = "Cat1", age = 18),
            Cat(name = "Cat3", age = 20),
            Dog(name = "Dog2", age = 8),
            Cat(name = "Cat2", age = 8),
            Bird(name = "Bird2", age = 14),
            Bird(name = "Bird3", age = 16),
            Dog(name = "Dog1", age = 18)
    )

    //篩選出個全部Dog的信息，藉助filterIsInstance操做符
    animalList.filterIsInstance<Dog>().forEach { println("${it.name} is ${it.age} years old, and ${it.eatFood()}") }
}
複製代碼

filterNot和filterNotTo操做符

一、基本定義

從一個集合篩選出符合條件以外的元素，並以一個新集合返回，它是filter操做符取反操做。

二、源碼定義

public inline fun <T> Iterable<T>.filterNot(predicate: (T) -> Boolean): List<T> {
    return filterNotTo(ArrayList<T>(), predicate)
}
public inline fun <T, C : MutableCollection<in T>> Iterable<T>.filterNotTo(destination: C, predicate: (T) -> Boolean): C {
    for (element in this) if (!predicate(element)) destination.add(element)
    return destination
}
複製代碼

三、源碼解析

實際上filterNot沒什麼可說的，它也是藉助於filterNotTo操做具體，和filterTo惟一區別就是判斷條件取反

四、原理圖解

五、使用場景

使用場景就是filter使用的取反條件使用，固然你也能夠繼續使用filter操做符，而且篩選條件爲取反條件。

filterNotNull和filterNotNullTo操做符

一、基本定義

filterNotNull操做符能夠過濾集合中爲null的元素,那麼同理filterNotNullTo纔是真正過濾操做，可是須要從外部傳入一個可變集合。

二、源碼定義

public fun <T : Any> Iterable<T?>.filterNotNull(): List<T> {
    return filterNotNullTo(ArrayList<T>())
}

public fun <C : MutableCollection<in T>, T : Any> Iterable<T?>.filterNotNullTo(destination: C): C {
    for (element in this) if (element != null) destination.add(element)
    return destination
}
複製代碼

三、源碼解析

filterNotNull是集合的擴展函數，該集合中的元素是可null的T泛型，那麼這個篩選條件也就是判斷是否爲null,篩選條件內部肯定好的。filterNotNull仍是繼續傳入一個可變集合，而後在filterNotNullTo內部判斷把null的元素直接過濾，其餘元素就會被加入傳入的可變集合中。

四、使用場景

filterNotNull操做符使用場景: 通常用於過濾掉集合中爲null的元素，最後返回一個不含null的元素集合。

filterNotNullTo操做符使用場景: 通常在外部傳入一個可變的集合，而後過濾多個集合中爲null的元素，最後將這些元素放入可變集合中，並返回這個集合。

fun main(args: Array<String>) {
    val animalList: List<Animal?> = listOf(Bird(name = "Bird1", age = 12),
            Cat(name = "Cat1", age = 18),
            Cat(name = "Cat3", age = 20),
            Dog(name = "Dog2", age = 8),
            null,
            Bird(name = "Bird2", age = 14),
           null,
            Dog(name = "Dog1", age = 18)
    )

    animalList.filterNotNull().forEach { println("${it.name} is ${it.age} years old and it ${it.eatFood()}") }
}
複製代碼

drop操做符

一、基本定義

根據傳入數值n，表示從左到右順序地刪除n個集合中的元素，並返回集合中剩餘的元素。

二、源碼定義

public fun <T> Iterable<T>.drop(n: Int): List<T> {
    require(n >= 0) { "Requested element count $n is less than zero." }
    if (n == 0) return toList()//要刪除元素爲0，說明剩餘元素集合正好取整個集合
    val list: ArrayList<T>//聲明一個可變集合
    if (this is Collection<*>) {//若是原集合是一個只讀的Collection或者其子類，那麼原集合的size是可肯定的，那麼建立新集合size是能夠作差計算獲得的
        val resultSize = size - n//拿原集合的size與起始下標作差值肯定最終返回的集合的大小resultSize
        if (resultSize <= 0)//集合的size小於或等於0直接返回空集合
            return emptyList()
        if (resultSize == 1)//resultSize等於1說明就直接返回原集合的最後一個元素
            return listOf(last())
        list = ArrayList<T>(resultSize)//建立resultSize大小的可變集合
        if (this is List<T>) {
            if (this is RandomAccess) {//RandomAccess是一個集合標記接口,若是集合類是RandomAccess的實現，則儘可能用index下標 來遍歷而不要用Iterator迭代器來遍歷，在效率上要差一些。反過來，若是List是Sequence List，則最好用迭代器來進行迭代。
                for (index in n until size)//採用下標遍歷
                    list.add(this[index])
            } else {
                for (item in listIterator(n))//採用迭代器遍歷
                    list.add(item)
            }
            return list
        }
    }
    else {//若是原集合是一個可變的集合，那麼就沒法經過計算確切的新集合的size。
        list = ArrayList<T>()
    }
    var count = 0
    for (item in this) {
        if (count++ >= n) list.add(item)//對於可變集合經過遍歷，計數累加的方式，當計數器超過起始下標就開始往集合中添加元素。
    }
    return list.optimizeReadOnlyList()
}
複製代碼

三、原理圖解

四、使用場景 drop操做符通常是適用於把集合元素去除一部分，drop是順序的刪除，n則表示順序刪除幾個元素，最後返回剩餘元素集合

fun main(args: Array<String>) {
    val numberList = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
    numberList.drop(5).forEach { print("$it ") }
}
複製代碼

dropLast操做符

一、基本定義

根據傳入數值n，表示從右到左倒序地刪除n個集合中的元素，並返回集合中剩餘的元素。

二、源碼定義

public fun <T> List<T>.dropLast(n: Int): List<T> {
    require(n >= 0) { "Requested element count $n is less than zero." }
    return take((size - n).coerceAtLeast(0))//這裏應該是this.take(),this指代List,而後傳入(size - n)必須知足大於或等於0
}

//這是一個Int類型的擴展函數，用於判斷某個值是否大於傳入默認最小值，若是大於就直接返回這個值，不然返回這個默認最小值
public fun Int.coerceAtLeast(minimumValue: Int): Int {
    return if (this < minimumValue) minimumValue else this
}

//take也是一種操做符
public fun <T> Iterable<T>.take(n: Int): List<T> {
    require(n >= 0) { "Requested element count $n is less than zero." }
    if (n == 0) return emptyList()//這裏n 其實是size - dropLast傳入n的差值，n爲0表示dropLast傳入n爲原集合size,至關於刪除原集合size個數元素，那麼剩下就是空集合了
    if (this is Collection<T>) {//若是是一個只讀類型集合，就能夠肯定該集合的size
        if (n >= size) return toList()//若是這裏n等於size表示dropLast傳入n爲0，那麼表示刪除集合元素個數爲0,那麼剩下來就是整個原集合了
        if (n == 1) return listOf(first())//若是n等於1，表示dropLasr傳入n爲size-1,那麼表示刪除集合個數size-1個，因爲刪除順序是倒序的，天然原集合剩下的元素就是第一個元素了。
    }
    //如下是針對this是一個可變集合，因爲可變集合的size不太好肯定，因此採用另外一方式實現dropLast功能。
    var count = 0
    val list = ArrayList<T>(n)//建立剩餘集合元素size大小n的可變集合
    for (item in this) {//因爲是從右到左遞增刪除的，取剩餘，如今是採用逆向方式，從左到右加入新的集合中，一直等待count計數器自增到n爲止。
        if (count++ == n)
            break
        list.add(item)
    }
    return list.optimizeReadOnlyList()
}

複製代碼

三、原理圖解

四、使用場景

使用的場景和drop相反，可是總體做用和drop相似。

fun main(args: Array<String>) {
    val strList = listOf("kotlin", "java", "javaScript", "C", "C++", "python", "Swift", "Go", "Scala")
    strList.dropLast(3).forEach { print("$it ") }
}
複製代碼

dropWhile操做符

一、基本定義

從集合的第一項開始去掉知足條件元素，這樣操做一直持續到出現第一個不知足條件元素出現爲止，返回剩餘元素(可能剩餘元素有知足條件的元素)

二、源碼定義

public inline fun <T> Iterable<T>.dropWhile(predicate: (T) -> Boolean): List<T> {
    var yielding = false//初始化標誌位false
    val list = ArrayList<T>()//建立一個新的可變集合
    for (item in this)//遍歷原集合
        if (yielding)//該標誌一直爲false直到，不符合lambda表達式外部傳入條件時，該標記爲置爲true,纔開始往新集合添加元素
            list.add(item)
        else if (!predicate(item)) {//判斷不符合外部傳入的條件，纔開始往新集合添加元素，標記置爲true，
        //這樣就知足了需求，一開始符合條件元素不會被添加到新集合中，不符合條件纔開始加入新集合，這樣產生新集合相對於原集合而言也就是刪除符合條件元素直到出現不符合條件的爲止
            list.add(item)
            yielding = true
        }
    return list
}
複製代碼

三、原理圖解

四、使用場景

適用於去掉集合中前半部分具備相同特徵的元素場景。

fun main(args: Array<String>) {
    val strList = listOf("java", "javaScript", "kotlin", "C", "C++", "javaFx","python", "Swift", "Go", "Scala")
    strList.dropWhile { it.startsWith("java") }.forEach { print("$it ") }
}
複製代碼

dropLastWhile操做符

一、基本定義

從集合的最後一項開始去掉知足條件元素，這樣操做一直持續到出現第一個不知足條件元素出現爲止，返回剩餘元素(可能剩餘元素有知足條件的元素)

二、源碼定義

public inline fun <T> List<T>.dropLastWhile(predicate: (T) -> Boolean): List<T> {
    if (!isEmpty()) {
        val iterator = listIterator(size)//表示從原集合尾部開始向頭部迭代
        while (iterator.hasPrevious()) {//當前元素存在上一個元素進入迭代
            if (!predicate(iterator.previous())) {//直到出現上一個元素不符合條件，纔開始取相應後續元素，加入到新集合中
                return take(iterator.nextIndex() + 1)
            }
        }
    }
    return emptyList()
}
複製代碼

三、原理圖解

四、使用場景

使用的場景和dropWhile相似，不過刪除元素順序不同

fun main(args: Array<String>) {
    val strList = listOf("java", "javaScript", "kotlin", "C", "C++", "javaFx", "python","Go", "Swift", "Scala")
    strList.dropLastWhile { it.startsWith("S") }.forEach { print("$it ") }
}
複製代碼

take操做符

一、基本定義

從原集合的第一項開始順序取集合的元素，取n個元素，最後返回取出這些元素的集合。換句話說就是取集合前n個元素組成新的集合返回。

二、源碼定義

public fun <T> Iterable<T>.take(n: Int): List<T> {
    require(n >= 0) { "Requested element count $n is less than zero." }
    if (n == 0) return emptyList()//n爲0表示取0個元素的集合，返回空集合
    if (this is Collection<T>) {//若是是隻讀集合，可肯定集合的size
        if (n >= size) return toList()//若是要取元素集合大小大於或等於原集合大小那麼就直接返回原集合
        if (n == 1) return listOf(first())//從第一項開始取1個元素，因此就是集合的first()
    }
    var count = 0
    val list = ArrayList<T>(n)//建立一個n大小可變集合
    for (item in this) {//遍歷原集合
        if (count++ == n)//自增計數器count大小超過要取元素個數，就跳出循環
            break
        list.add(item)
    }
    return list.optimizeReadOnlyList()
}
複製代碼

三、原理圖解

四、使用場景

適用於順序從第一項開始取集合中子集合

fun main(args: Array<String>) {
    val strList = listOf("java", "javaScript", "kotlin", "C", "C++", "javaFx", "python","Go", "Swift", "Scala")
    strList.take(2).forEach { print("$it ") }
}
複製代碼

takeLast操做符

一、基本定義

從原集合的最後一項開始倒序取集合的元素，取n個元素，最後返回取出這些元素的集合。

二、源碼定義

public fun <T> List<T>.takeLast(n: Int): List<T> {
    require(n >= 0) { "Requested element count $n is less than zero." }
    if (n == 0) return emptyList()//n爲0表示取0個元素的集合，返回空集合
    val size = size
    if (n >= size) return toList()//若是取的元素集合大小大於size直接返回整個集合
    if (n == 1) return listOf(last())//從最後一項開始取1個元素，天然就是返回last()
    val list = ArrayList<T>(n)//建立一個n大小的可變集合
    if (this is RandomAccess) {//RandomAccess是一個集合標記接口,若是集合類是RandomAccess的實現，則儘可能用index下標 來遍歷而不要用Iterator迭代器來遍歷，在效率上要差一些。反過來，若是List是Sequence List，則最好用迭代器來進行迭代。
        for (index in size - n until size)//採用下邊遍歷
            list.add(this[index])
    } else {
        for (item in listIterator(size - n))//採用迭代器遍歷
            list.add(item)
    }
    return list
}
複製代碼

三、原理圖解

四、使用場景

適用於倒序從最後一項開始取集合中子集合

fun main(args: Array<String>) {
    val strList = listOf("java", "javaScript", "kotlin", "C", "C++", "javaFx", "python","Go", "Swift", "Scala")
    strList.takeLast(2).forEach { print("$it ") }
}
複製代碼

takeLastWhile操做符

一、基本定義

從集合的最後一項開始取出知足條件元素，這樣操做一直持續到出現第一個不知足條件元素出現爲止，暫停取元素，返回取出元素的集合。

二、源碼定義

public inline fun <T> List<T>.takeLastWhile(predicate: (T) -> Boolean): List<T> {
    if (isEmpty())//若是當前集合是一個空的，那麼直接返回空集合
        return emptyList()
    val iterator = listIterator(size)//表示從集合index = size開始迭代,那麼size - 1也是最後一個元素，也便是迭代器的previous,也就是從集合尾部開始向頭部迭代
    while (iterator.hasPrevious()) {//含有上一個元素的元素繼續進入迭代
        if (!predicate(iterator.previous())) {//直到某個元素的前一個元素不符合條件，也是從最後一項開始遇到第一個不符合條件的元素，不進入如下操做
            iterator.next()
            val expectedSize = size - iterator.nextIndex()//因爲從尾部開始迭代，那麼符合條件元素集合的expectedSize等於原集合size與當前下一個元素的index的差值
            if (expectedSize == 0) return emptyList()//差值爲0的話說明，在原集合尾部開始迭代就不符合條件被終止，因此返回空集合
            return ArrayList<T>(expectedSize).apply {//拿到符合條件元素集合size，建立expectedSize大小新集合，並把迭代器中的元素遍歷加入到新集合中
                while (iterator.hasNext())
                    add(iterator.next())
            }
        }
    }
    return toList()
}
複製代碼

三、源碼解析

takeLastWhile操做符是一個集合的擴展內聯函數，也是一個高階函數，它接收一個以接收T泛型參數返回一個Boolean類型的Lambda表達式，也是便是takeLastWhile取元素的條件的實現。

四、原理圖解

五、使用場景

適用於取出集合中後半部分具備相同特徵的元素場景。

fun main(args: Array<String>) {
    val strList = listOf("java", "javaScript", "kotlin", "C", "C++", "javaFx", "python","Go", "Swift", "Scala")
    strList.takeLastWhile { it.startsWith("S") }.forEach { print("$it ") }
}
複製代碼

takeWhile操做符

一、基本定義

從集合的第一項開始取出知足條件元素，這樣操做一直持續到出現第一個不知足條件元素出現爲止，暫停取元素，返回取出元素的集合。

二、源碼定義

public inline fun <T> Iterable<T>.takeWhile(predicate: (T) -> Boolean): List<T> {
    val list = ArrayList<T>()//建立一個可變集合
    for (item in this) {//遍歷原集合
        if (!predicate(item))//不符合傳入條件就直接跳出訓練
            break
        list.add(item)//符合條件的直接加入到新集合
    }
    return list//最後返回新集合
}
複製代碼

三、源碼解析

takeWhile操做符是一個集合的擴展內聯函數，也是一個高階函數，它接收一個以接收T泛型參數返回一個Boolean類型的Lambda表達式，也是便是takeWhile取元素的條件的實現。遍歷整個原集合，符合條件的加入到新集合中，一旦遇到不符合條件元素直接跳出循環，也就是遇到第一個不符合條件的就終止取元素的操做，最後返回這個新集合。

四、原理圖解

五、使用場景

適用於取出集合中前半部分具備相同特徵的元素場景。

fun main(args: Array<String>) {
    val strList = listOf("java", "javaScript", "kotlin", "C", "C++", "javaFx", "python","Go", "Swift", "Scala")
    strList.takeWhile { it.startsWith("java") }.forEach { print("$it ") }
}
複製代碼