Kotlin之“AbstractMutableList”

簡介

AbstractMutableList 是一個超級好用的抽象類侧啼，里面實現(xiàn)了好多對集合操作的直觀方法，新鮮事物基本就體現(xiàn)在這里。哪怕是暫時用不到沟堡，至少也得先看看有些啥，能干點啥吧矢空。

出身

abstract class AbstractMutableList<E> : MutableList<E>,AbstractList<E>

AbstractMutableList實現(xiàn)了兩個接口弦叶，其中：

  • MutableList 使得它的集合長度可變，該接口不提供管理容量大小的方法妇多，像js中的array一樣自動改變大小
  • AbstractList 定義了一般List的方法結(jié)構伤哺，也就是說所有的List都必須有的方法，比如需要實現(xiàn)一個容量不可變的數(shù)組者祖，直接實現(xiàn)這個接口立莉，并提供get(Int)和size()方法就可以了

構造方法（Constructors）

  • 提供MutableList接口的原始實現(xiàn)框架
AbstractMutableList()

參數(shù)

  • modCount 繼承來的參數(shù)，js中表示該集合的結(jié)構變化次數(shù)
var modCount: Int

原始方法和繼承來的方法（參照ArrayList ）

擴展參數(shù)

val Collection<*>.indices: IntRange

val <T> List<T>.lastIndex: Int

擴展方法（重頭戲）

  • addAll (不解釋)
fun <T> MutableCollection<in T>.addAll(elements: Iterable<T>): Boolean
fun <T> MutableCollection<in T>.addAll(elements: Sequence<T>): Boolean
fun <T> MutableCollection<in T>.addAll(elements: Array<out T>): Boolean
  • all
//如果所有的元素都符合后面指定的斷言七问，則返回true蜓耻，否則返回false
fun <T> Iterable<T>.all(predicate: (T) -> Boolean): Boolean
  • any
//如果該集合至少有一個元素就返回true，否則為false
fun <T> Iterable<T>.any(): Boolean
//如果該集合至少有一個元素符合后面指定的斷言械巡，就返回true刹淌，否則為false
fun <T> Iterable<T>.any(predicate: (T) -> Boolean): Boolean
  • asIterable
//將該集合作為一個Iterable返回
fun <T> Iterable<T>.asIterable(): Iterable<T>
  • asSequence
//創(chuàng)建一個Sequence對象包含集合的原始元素，當被遍歷時返回元素
fun <T> Iterable<T>.asSequence(): Sequence<T>
  • associate
//根據(jù)指定的變換方法讥耗，返回一個Map對象
fun <T, K, V> Iterable<T>.associate(transform: (T) -> Pair<K, V>): Map<K, V>
  • associateBy
//指定返回Map的key與元素之間的對應關系
fun <T, K> Iterable<T>.associateBy( keySelector: (T) -> K): Map<K, T>
//指定返回的Map的key和value
fun <T, K, V> Iterable<T>.associateBy(keySelector: (T) -> K, valueTransform: (T) -> V): Map<K, V>
  • associateTo
//指定返回的Map類型（必須是MutableMap類）和變換方法
fun <T, K, V, M : MutableMap<in K, in V>> Iterable<T>.associateTo(
    destination: M, 
    transform: (T) -> Pair<K, V>
): M
  • associateByTo
//指定返回的Map類型（必須是MutableMap類）和key與元素之間的對應關系
fun <T, K, M : MutableMap<in K, in T>> Iterable<T>.associateByTo(
    destination: M, 
    keySelector: (T) -> K
): M
//指定返回的Map類型（必須是MutableMap類）和key有勾、value與元素之間的對應關系
fun <T, K, V, M : MutableMap<in K, in V>> Iterable<T>.associateByTo(
    destination: M, 
    keySelector: (T) -> K, 
    valueTransform: (T) -> V
): M
  • binarySearch（如果結(jié)果有多個，不保證返回的是哪一個結(jié)果的位置）
//使用二分搜索法搜索元素古程，前提元素實現(xiàn)了Comparable接口蔼卡，查找范圍默認為整個集合，可以不指定
fun <T : Comparable<T>> List<T?>.binarySearch(
    element: T?, 
    fromIndex: Int = 0, 
    toIndex: Int = size
): Int
//如果元素沒有實現(xiàn)Comparable接口挣磨，也可以在這里指定
fun <T> List<T>.binarySearch(
    element: T, 
    comparator: Comparator<in T>, 
    fromIndex: Int = 0, 
    toIndex: Int = size
): Int
//不寫具體的某個元素雇逞，根據(jù)comparison也能找出結(jié)果荤懂，是通過判斷comparison的結(jié)果是否為0
fun <T> List<T>.binarySearch(
    fromIndex: Int = 0, 
    toIndex: Int = size, 
    comparison: (T) -> Int
): Int
  • binarySearchBy
//使用二分搜索法找出集合中能通過selector方法和key對應上的元素位置
fun <T, K : Comparable<K>> List<T>.binarySearchBy(
    key: K?, 
    fromIndex: Int = 0, 
    toIndex: Int = size, 
    selector: (T) -> K?
): Int
  • component1（1~5太尼瑪貼心了(?????)）
//從上到下依次是返回第一個元素到返回第五個元素
operator fun <T> List<T>.component1(): T
operator fun <T> List<T>.component2(): T
operator fun <T> List<T>.component3(): T
operator fun <T> List<T>.component4(): T
operator fun <T> List<T>.component5(): T
  • contains
//檢查指定的元素是否包含在該集合當中
open fun contains(element: E): Boolean
  • containsAll
//檢查是否所有的元素都包含在了集合當中
fun <T> Collection<T>.containsAll(
    elements: Collection<T>
): Boolean
  • count
//返回集合中的元素符合給出的斷言的個數(shù)
fun <T> Iterable<T>.count(predicate: (T) -> Boolean): Int
  • distinct
//去重
fun <T> Iterable<T>.distinct(): List<T>
  • distinctBy
//帶去重規(guī)則的去重，這里的意思就是不根據(jù)元素本身去比較塘砸，而是用轉(zhuǎn)換成的K來做去重
fun <T, K> Iterable<T>.distinctBy(
    selector: (T) -> K
): List<T>
  • drop
//去掉前幾個元素节仿，如果參數(shù)n大于集合長度，那就返回一個空集合掉蔬，n不能小于0,
fun <T> Iterable<T>.drop(n: Int): List<T>
  • dropLast
//去掉后幾個元素粟耻，如果參數(shù)n大于集合長度，那就返回一個空集合眉踱，n不能小于0,
fun <T> List<T>.dropLast(n: Int): List<T>
  • dropLastWhile
//倒序遍歷集合挤忙，如果元素滿足條件則去掉，直到遇到不滿足判斷條件的元素為止谈喳，把剩下的元素集合返回
fun <T> List<T>.dropLastWhile(
    predicate: (T) -> Boolean
): List<T>
  • dropWhile
//遍歷集合册烈，如果元素滿足條件則去掉，直到遇到不滿足判斷條件的元素為止婿禽，把剩下的元素集合返回
fun <T> List<T>.dropWhile(
    predicate: (T) -> Boolean
): List<T>
  • elementAtOrElse
//獲取集合中index位置的元素赏僧，如果越界了就返回默認元素
fun <T> Iterable<T>.elementAtOrElse(index: Int, defaultValue: (Int) -> T): T
//如果目標是List，那么就相當于直接調(diào)用getOrElse方法
fun <T> List<T>.elementAtOrElse(index: Int, defaultValue: (Int) -> T): T
  • filter
//選出集合中符合條件的所有元素
fun <T> Iterable<T>.filter(
    predicate: (T) -> Boolean
): List<T>
  • filter
//選出集合中符合條件的所有元素
fun <T> Iterable<T>.filter(
    predicate: (T) -> Boolean
): List<T>
  • filterIndexed
//和filter作用一樣扭倾，只是判斷條件里多了一個index參數(shù)
//例如：array.filterIndexed({index, it -> index>it }).forEach(::println)
fun <T> Iterable<T>.filterIndexed(
    predicate: (index: Int, T) -> Boolean
): List<T>
  • filterIndexedTo
//作用同filter淀零，只是這里可以把篩選結(jié)果轉(zhuǎn)換成你想要的類型C，在filterIndexed內(nèi)部其實就是直接調(diào)用的它
fun <T, C : MutableCollection<in T>> Iterable<T>.filterIndexedTo(
    destination: C, 
    predicate: (index: Int, T) -> Boolean
): C
  • filterIsInstance
//選出集合中元素類型為R類型的所有元素集合膛壹，內(nèi)部其實直接調(diào)用的是filterIsInstanceTo方法驾中，下面會介紹
fun <R> Iterable<*>.filterIsInstance(): List<R>
//也可以這樣寫，兩種寫法模聋，作用一樣
fun <R> Iterable<*>.filterIsInstance(
    klass: Class<R>
): List<R>
  • filterIsInstanceTo
//將根據(jù)類型選出來的元素放到一個指定類型的集合C中
fun <R, C : MutableCollection<in R>>Iterable<*>.filterIsInstanceTo(
    destination: C
): C
//依然是兩種寫法
fun <C : MutableCollection<in R>, R>Iterable<*>.filterIsInstanceTo(
    destination: C, 
    klass: Class<R>
): C
  • filterNot
//與filter相反肩民，這個方法篩選出所有不符合條件的元素
fun <T> Iterable<T>.filterNot(
    predicate: (T) -> Boolean
): List<T>
  • filterNotNull
//顧名思義，篩選出所有非空的元素
fun <T : Any> Iterable<T?>.filterNotNull(): List<T>
  • filterNotNullTo
//篩選出所有非空的元素并放到指定類型的集合中
fun <C : MutableCollection<in T>, T : Any> Iterable<T?>.filterNotNullTo(
    destination: C
): C
  • filterTo
//根據(jù)指定篩選條件篩選出來的元素放入指定類型的集合中
fun <T, C : MutableCollection<in T>> Iterable<T>.filterTo(
    destination: C, 
    predicate: (T) -> Boolean
): C
  • find（注意和filter的區(qū)分）
//查找第一個與判斷條件相符的元素链方，如果沒有則返回null
//內(nèi)部直接調(diào)用的firstOrNull方法持痰，下面會介紹這個方法
fun <T> Iterable<T>.find(predicate: (T) -> Boolean): T?
  • findLast
//查找最后一個與判斷條件相符的元素，如果沒有則返回null
//內(nèi)部直接調(diào)用的lastOrNull方法祟蚀，下面會介紹這個方法
fun <T> Iterable<T>.findLast(predicate: (T) -> Boolean): T?
fun <T> List<T>.findLast(predicate: (T) -> Boolean): T?
  • first（注意和find的區(qū)分）
//返回第一個符合條件的元素工窍，注意，這里如果找不到符合條件的元素會拋出異常
//如果沒找到拋出NoSuchElementException
//如果不寫判斷條件默認返回集合的第一個元素,注意前酿，如果集合為空也會拋出異常
fun <T> Iterable<T>.first(predicate: (T) -> Boolean): T
  • firstOrNull
//如果不寫判斷條件蝌戒，則默認返回第一個元素访惜，如果集合為空則返回null
//有判斷條件的話則返回符合判斷條件的第一個元素栋烤，沒有則返回null
fun <T> List<T>.firstOrNull(): T?
fun <T> Iterable<T>.firstOrNull(): T?
fun <T> Iterable<T>.firstOrNull(predicate: (T) -> Boolean): T?
  • flatMap
//根據(jù)指定的轉(zhuǎn)換關系舶得，將每一個元素單獨做成Iterable
//最后再利用addAll()方法冷冗，將所有的新Iterable放到一個新數(shù)組里面
//內(nèi)部實現(xiàn)是調(diào)用的flatMapTo方法，下面介紹
fun <T, R> Iterable<T>.flatMap(
    transform: (T) -> Iterable<R>
): List<R>
  • flatMapTo
//像flatMap中一樣荣暮，將每個元素轉(zhuǎn)換成Iterable进副，只是這里制定了返回的集合類型
fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapTo(
    destination: C, 
    transform: (T) -> Iterable<R>
): C
  • fold
//指定初始值R，之后遍歷所有元素悬槽，每個元素通過指定的運算之后將結(jié)果傳遞到下次運算怀吻，最終把結(jié)果返回
//例如我要計算集合所有元素的和：array.fold(0,{acc, it -> it + acc }
fun <T, R> Iterable<T>.fold(
    initial: R, 
    operation: (acc: R, T) -> R
): R
  • foldIndexed
//功能參考fold，這里只是在運算時多了一個元素的位置參數(shù)index
fun <T, R> Iterable<T>.foldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, T) -> R
): R
  • foldRight
//功能參考fold初婆，但這里是倒序蓬坡，從最后一個元素開始遍歷
fun <T, R> List<T>.foldRight(
    initial: R, 
    operation: (T, acc: R) -> R
): R
  • foldRightIndexed
//功能參考foldIndexed，只是這里是倒序磅叛，從最后一個元素開始遍歷
fun <T, R> List<T>.foldRightIndexed(
    initial: R, 
    operation: (index: Int, T, acc: R) -> R
): R
  • forEach
//遍歷集合最常用的方法之一屑咳，括號里可以對每個元素進行操作
fun <T> Iterable<T>.forEach(action: (T) -> Unit)
  • forEachIndexed
//功能參考forEach，只是這里多了一個元素位置參數(shù)index
fun <T> Iterable<T>.forEachIndexed(
    action: (index: Int, T) -> Unit)
  • getOrElse
//獲取集合中index位置的元素弊琴，如果越界了就返回默認元素兆龙，注意和elementAtOrElse區(qū)分
fun <T> List<T>.getOrElse(
    index: Int, 
    defaultValue: (Int) -> T
): T
  • getOrNull
//獲取集合中index位置的元素，如果越界了就返回null
fun <T> List<T>.getOrNull(
    index: Int, 
): T
  • groupBy
//通過指定一個規(guī)則將list進行分組敲董，將結(jié)果整合成Map紫皇，Map的key則根據(jù)keySelector指定
//內(nèi)部實現(xiàn)直接調(diào)用groupByTo方法，返回類型默認腋寨，下面會有介紹
fun <T, K> Iterable<T>.groupBy(
    keySelector: (T) -> K
): Map<K, List<T>>
//當然如果指定了value的變化規(guī)則聪铺，那么最后Map中的list的元素也將可以根據(jù)規(guī)則指定
fun <T, K, V> Iterable<T>.groupBy(
    keySelector: (T) -> K, 
    valueTransform: (T) -> V
): Map<K, List<V>>
  • groupByTo
//功能參考groupBy，只是它可以手動指定返回的Map類型
fun <T, K, M : MutableMap<in K, MutableList<T>>> Iterable<T>.groupByTo(
    destination: M, 
    keySelector: (T) -> K
): M
fun <T, K, V, M : MutableMap<in K, MutableList<V>>> Iterable<T>.groupByTo(
    destination: M, 
    keySelector: (T) -> K, 
    valueTransform: (T) -> V
): M
  • groupingBy （1.1版本方法）
//根據(jù)指定的keySelector創(chuàng)建分組萄窜，以便于之后從分組中的元素獲取其分組名铃剔，也就是key
//通過調(diào)用它的keyOf方法可以獲取元素的分組名也就是key
fun <T, K> Iterable<T>.groupingBy(
    keySelector: (T) -> K
): Grouping<T, K>
  • indexOf
//返回該指定元素在集合中的第一個索引位置，如果不存在就返回-1
fun <T> Iterable<T>.indexOf(element: T): Int
fun <T> List<T>.indexOf(element: T): Int
  • indexOfFirst
//返回滿足斷言的指定元素在集合中的第一個索引位置查刻，如果不存在就返回-1
fun <T> Iterable<T>.indexOfFirst(
    predicate: (T) -> Boolean
): Int
fun <T> List<T>.indexOfFirst(predicate: (T) -> Boolean): Int
  • indexOfLast
//與indexOfFirst相反番宁，返回滿足斷言的指定元素在集合中的最后一個索引位置，如果不存在就返回-1
fun <T> Iterable<T>.indexOfLast(
    predicate: (T) -> Boolean
): Int
fun <T> List<T>.indexOfLast(predicate: (T) -> Boolean): Int
  • intersect
//找出與指定集合中共有的元素集合（不會有重復的元素赖阻，因為是Set類型）
infix fun <T> Iterable<T>.intersect(
    other: Iterable<T>
): Set<T>
  • isNotEmpty
//判斷集合是否不為空蝶押，其實就是內(nèi)部調(diào)用！isEmpty(),
//而isEmpty()方法內(nèi)部是判斷的size是否等于0
fun <T> Collection<T>.isNotEmpty(): Boolean
  • joinTo
//將集合拼接成buffer
fun <T, A> Iterable<T>.joinTo(
    buffer: A, //buffer對象
    separator: CharSequence = ", ", //分割用的火欧，默認是逗號
    prefix: CharSequence = "", //拼在開頭部分的內(nèi)容
    postfix: CharSequence = "", //拼在結(jié)尾部分的內(nèi)容
    limit: Int = -1, //要拼的元素個數(shù)棋电，默認為-1，就是沒有任何限制苇侵，把所有的元素都拼上
    truncated: CharSequence = "...", //如果集合中元素個數(shù)大于limit值赶盔，則在后面拼上truncated，默認是三個點
    transform: (T) -> CharSequence = null//集合中元素的轉(zhuǎn)換方式
): A

假設我有一個包含數(shù)字1~6的集合榆浓，我要把他們拼一下：

array.joinTo(StringBuffer(),":","prefix","postfix",-1,"truncated",{it.toString()})
array.joinTo(StringBuffer(),":","prefix","postfix",3,"truncated",{it.toString()})

打印結(jié)果分別為
prefix1:2:3:4:5:6postfix
prefix1:2:3:truncatedpostfix

  • joinToString
//功能參考joinTo于未，這個方法只是在內(nèi)部在joinTo的基礎上調(diào)用了.toString()而已
fun <T> Iterable<T>.joinToString(
    separator: CharSequence = ", ", 
    prefix: CharSequence = "", 
    postfix: CharSequence = "", 
    limit: Int = -1, 
    truncated: CharSequence = "...", 
    transform: (T) -> CharSequence = null
): String
  • last
//返回集合中最后一個符合斷言的元素,注意：如果找不到符合的元素會拋出異常
fun <T> Iterable<T>.last(predicate: (T) -> Boolean): T
fun <T> List<T>.last(predicate: (T) -> Boolean): T
//返回集合中最后一個元素，如果集合為空則拋出異常
fun <T> List<T>.last(): T
  • lastIndexOf
//返回該元素的最后一個索引位置，如果沒有的話則返回-1    
fun <T> Iterable<T>.lastIndexOf(element: T): Int
fun <T> List<T>.lastIndexOf(element: T): Int
  • lastOrNull
//返回集合中最后一個符合斷言的元素,注意：如果找不到符合的元素則返回null
fun <T> Iterable<T>.lastOrNull(predicate: (T) -> Boolean): T?
fun <T> List<T>.lastOrNull(predicate: (T) -> Boolean): T?
  • map
//將集合所有元素根據(jù)transform進行變換烘浦，然后返回新集合抖坪，其實里面就是個for循環(huán)
fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R>
  • mapIndexed
//功能參考map，只是在遍歷是多一個元素位置索引參數(shù)index
fun <T, R> Iterable<T>.mapIndexed(
    transform: (index: Int, T) -> R
): List<R>
  • mapIndexedNotNull
//功能參考mapIndexed闷叉，返回的集合里不包含空對象
fun <T, R : Any> Iterable<T>.mapIndexedNotNull(
    transform: (index: Int, T) -> R?
): List<R>
  • mapIndexedNotNullTo
//在mapIndexedNotNull基礎上增加了指定返回對象類型功能
fun <T, R : Any, C : MutableCollection<in R>> Iterable<T>.mapIndexedNotNullTo(
    destination: C, 
    transform: (index: Int, T) -> R?
): C
  • mapIndexedTo
//在mapIndexed的基礎上增加了指定返回對象類型的功能
fun <T, R, C : MutableCollection<in R>> Iterable<T>.mapIndexedTo(
    destination: C, 
    transform: (index: Int, T) -> R
): C
  • mapNotNull
//在map的基礎上過濾掉了null元素對象  
fun <T, R : Any> Iterable<T>.mapNotNull(
    transform: (T) -> R?
): List<R>
  • mapNotNullTo
//在mapNotNull的基礎上增加了指定返回對象類型的功能
fun <T, R : Any, C : MutableCollection<in R>> Iterable<T>.mapNotNullTo(
    destination: C, 
    transform: (T) -> R?
): C
  • mapTo
//在map的基礎上增加了指定返回對象類型的功能
fun <T, R, C : MutableCollection<in R>> Iterable<T>.mapTo(
    destination: C, 
    transform: (T) -> R
): C
  • max
//返回集合中最大的元素擦俐，前提是元素得實現(xiàn)Comparable接口，如果集合為空則返回null
fun <T : Comparable<T>> Iterable<T>.max(): T?
  • maxBy
//對集合中的每個元素進行轉(zhuǎn)換之后比值握侧，返回轉(zhuǎn)換后的值最大的元素蚯瞧，如果集合為空則返回null
fun <T, R : Comparable<R>> Iterable<T>.maxBy(
    selector: (T) -> R
): T?
  • maxWith
//根據(jù)指定的比較規(guī)則，來選出集合中最大的元素
fun <T> Iterable<T>.maxWith(comparator: Comparator<in T>): T?
fun <T> Iterable<T>.maxWith(comparator: Comparator<in T>): T?
  • min品擎、minBy埋合、minWith為取最小元素，具體參照max萄传、maxBy饥悴、maxWith
  • minus
//去掉集合中指定的元素,如果集合中有多個這元素，則只去掉第一個
operator fun <T> Iterable<T>.minus(element: T): List<T>
//去掉集合中的多個元素盲再，這里如果指定多個一樣的元素也會被看作一個
operator fun <T> Iterable<T>.minus(
    elements: Array<out T>
): List<T>
operator fun <T> Iterable<T>.minus(
    elements: Iterable<T>
): List<T>
operator fun <T> Iterable<T>.minus(
    elements: Sequence<T>
): List<T>
  • minusAssign
//作用同minus西设，內(nèi)部直接調(diào)用remove()方法，注意與minus的區(qū)別答朋，這個沒有返回值
operator fun <T> MutableCollection<in T>.minusAssign(element: T)
//作用同minus贷揽，內(nèi)部直接調(diào)用removeAll()，這個也沒有返回值
operator fun <T> MutableCollection<in T>.minusAssign(elements: Iterable<T>)
operator fun <T> MutableCollection<in T>.minusAssign(elements: Array<T>)
operator fun <T> MutableCollection<in T>.minusAssign(elements: Sequence<T>)
  • minusElement
//內(nèi)部直接調(diào)用的minus
fun <T> Iterable<T>.minusElement(element: T): List<T>
  • none
//如果集合中沒有元素則返回true  
fun <T> Iterable<T>.none(): Boolean
//如果集合中沒有符合斷言的元素則返回true
fun <T> Iterable<T>.none(predicate: (T) -> Boolean): Boolean
  • partition
//將集合根據(jù)斷言分成兩個集合梦碗，并組成Pair對象禽绪，第一個List是符合斷言的所有元素，第二個是剩下的
fun <T> Iterable<T>.partition(
    predicate: (T) -> Boolean
): Pair<List<T>, List<T>>
  • plus
//將指定元素放到該集合中
operator fun <T> Iterable<T>.plus(element: T): List<T>
operator fun <T> Collection<T>.plus(element: T): List<T>
//將指定多個元素放到集合中
operator fun <T> Iterable<T>.plus(
    elements: Array<out T>
): List<T>
operator fun <T> Collection<T>.plus(
    elements: Array<out T>
): List<T>
operator fun <T> Iterable<T>.plus(
    elements: Iterable<T>
): List<T>
operator fun <T> Collection<T>.plus(
    elements: Iterable<T>
): List<T>
operator fun <T> Iterable<T>.plus(
    elements: Sequence<T>
): List<T>
operator fun <T> Collection<T>.plus(
    elements: Sequence<T>
): List<T>
  • plusAssign
//作用參考plus洪规，該方法沒有返回值
operator fun <T> MutableCollection<in T>.plusAssign(
    element: T)
operator fun <T> MutableCollection<in T>.plusAssign(
    elements: Iterable<T>)
operator fun <T> MutableCollection<in T>.plusAssign(
    elements: Array<T>)
operator fun <T> MutableCollection<in T>.plusAssign(
    elements: Sequence<T>)
  • plusElement
//作用參考plus
fun <T> Iterable<T>.plusElement(element: T): List<T>
fun <T> Collection<T>.plusElement(element: T): List<T>
  • reduce
//遍歷所有元素印屁，每個元素通過指定的運算之后將結(jié)果傳遞到下次運算，最終把結(jié)果返回
//注意和fold()的區(qū)別斩例，這個方法沒有設置初始值
fun <S, T : S> Iterable<T>.reduce(
    operation: (acc: S, T) -> S
): S
  • reduceIndexed
//功能參考reduce雄人，只是在指定運算方法時多了個參數(shù)index   
fun <S, T : S> Iterable<T>.reduceIndexed(
    operation: (index: Int, acc: S, T) -> S
): S
  • reduceRight
//倒序遍歷的reduce
fun <S, T : S> List<T>.reduceRight(
    operation: (T, acc: S) -> S
): S
  • reduceRightIndexed
//倒序遍歷的reduceIndexed
fun <S, T : S> List<T>.reduceRightIndexed(
    operation: (index: Int, T, acc: S) -> S
): S
  • remove、removeAll念赶、retainAll（不解釋）
  • reverse
//反轉(zhuǎn)集合中的元素順序
fun <T> MutableList<T>.reverse()
  • reversed
//將反轉(zhuǎn)之后的集合返回
fun <T> Iterable<T>.reversed(): List<T>
  • single
//如果集合為空則拋出異常础钠，如果集合里只有一個元素，則返回這個元素叉谜，如果多于一個元素則拋出異常
fun <T> List<T>.single(): T
//返回唯一滿足條件的元素旗吁，如果沒有找到或集合為空或找到多個都會拋出異常
fun <T> Iterable<T>.single(predicate: (T) -> Boolean): T
  • singleOrNull
//如果找到一個滿足條件的元素則返回這個元素，其他所有情況均返回null
fun <T> Iterable<T>.singleOrNull(
    predicate: (T) -> Boolean
): T?
  • slice
//指定一個int區(qū)間停局，然后根據(jù)這個int區(qū)間去調(diào)用subList()方法   ,如果沒指定區(qū)間則返回空集合
//：subList(indices.start, indices.endInclusive + 1)
fun <T> List<T>.slice(indices: IntRange): List<T>
//將指定的多個位置的元素提取出來成為一個集合
fun <T> List<T>.slice(indices: Iterable<Int>): List<T>
  • sort
//自然排序
fun <T : Comparable<T>> MutableList<T>.sort()
  • sortBy
//根據(jù)指定轉(zhuǎn)換規(guī)則轉(zhuǎn)換后的元素進行自然排序
fun <T, R : Comparable<R>> MutableList<T>.sortBy(
    selector: (T) -> R?)
  • sortByDescending
//根據(jù)指定轉(zhuǎn)換規(guī)則轉(zhuǎn)換后的元素進行自然倒序排序
fun <T, R : Comparable<R>> MutableList<T>.sortByDescending(
    selector: (T) -> R?)
  • sortDescending
//自然倒序排序
fun <T : Comparable<T>> MutableList<T>.sortDescending()
  • sortWith
//根據(jù)指定比較規(guī)則進行排序
fun <T> MutableList<T>.sortWith(comparator: Comparator<in T>)
fun <T> MutableList<T>.sortWith(comparator: Comparator<in T>)
  • sorted
//返回自然排序的結(jié)果
fun <T : Comparable<T>> Iterable<T>.sorted(): List<T>
  • sortedBy
//根據(jù)指定規(guī)則轉(zhuǎn)換后的元素進行自然排序很钓，然后把返回排序結(jié)果
fun <T, R : Comparable<R>> Iterable<T>.sortedBy(
    selector: (T) -> R?
): List<T>
  • sortedByDescending
//參考sortByDescending香府，只是這個方法會返回排序結(jié)果
fun <T, R : Comparable<R>> Iterable<T>.sortedByDescending(
    selector: (T) -> R?
): List<T>
  • sortedWith
//根據(jù)指定的比較規(guī)則進行排序，并返回排序結(jié)果 
fun <T> Iterable<T>.sortedWith(
    comparator: Comparator<in T>
): List<T>
fun <T> Iterable<T>.sortedWith(
    comparator: Comparator<in T>
): List<T>
  • subtract
//返回一個Set集合码倦，其中包含此集合的所有元素企孩，除了指定集合中的元素
infix fun <T> Iterable<T>.subtract(
    other: Iterable<T>
): Set<T>
  • sumBy
//將集合中所有元素根據(jù)指定轉(zhuǎn)換規(guī)則轉(zhuǎn)換的結(jié)果進行求和
fun <T> Iterable<T>.sumBy(selector: (T) -> Int): Int
  • sumByDouble
//參考sumBy，只是返回的結(jié)果為double類型
fun <T> Iterable<T>.sumByDouble(
    selector: (T) -> Double
): Double
  • take
//返回包含前n個元素的集合
fun <T> Iterable<T>.take(n: Int): List<T>
  • takeLast
//返回包含后n個元素的集合  
fun <T> List<T>.takeLast(n: Int): List<T>
  • takeWhile
//正序遍歷集合叹洲，將滿足條件的元素放入新集合并返回柠硕，
//直到遇見不符合條件的元素結(jié)束工禾，后面的元素就算滿足條件也不會被加入新集合
fun <T> Iterable<T>.takeWhile(
    predicate: (T) -> Boolean
): List<T>
  • takeLastWhile
//倒序遍歷集合运提，將滿足條件的元素放入新集合并返回，
//直到遇見不符合條件的元素結(jié)束闻葵，后面的元素就算滿足條件也不會被加入新集合
fun <T> List<T>.takeLastWhile(
    predicate: (T) -> Boolean
): List<T>
  • toCollection民泵、toHashSet、toList槽畔、toMutableSet栈妆、toSet、toSortedSet厢钧、toTypedArray（不解釋）
  • union
//返回一個set鳞尔，包含這兩個集合的所有元素，并且對元素去重
infix fun <T> Iterable<T>.union(other: Iterable<T>): Set<T>
  • withIndex
//返回一個包含所有元素的indexedValue的懶加載集合
fun <T> Iterable<T>.withIndex(): Iterable<IndexedValue<T>>
  • zip
//將兩個集合按順序取出元素早直，相同位置的兩個元素組成Pair對象寥假，并保存到新集合中返回，
//如果兩個集合長度不一樣霞扬，以短的為準 
infix fun <T, R> Iterable<T>.zip(
    other: Array<out R>
): List<Pair<T, R>>
infix fun <T, R> Iterable<T>.zip(
    other: Iterable<R>
): List<Pair<T, R>>
//將兩個集合按順序取出元素糕韧，相同位置的兩個元素按指定轉(zhuǎn)換規(guī)則轉(zhuǎn)換，并將結(jié)果保存到新集合中返回喻圃，
//如果兩個集合長度不一樣萤彩，以短的為準 
fun <T, R, V> Iterable<T>.zip(
    other: Array<out R>, 
    transform: (a: T, b: R) -> V
): List<V>
fun <T, R, V> Iterable<T>.zip(
    other: Iterable<R>, 
    transform: (a: T, b: R) -> V
): List<V>

總結(jié)

到這里所有的AbstractMutableList的神奇方法都已經(jīng)介紹完畢了，感覺不會有人能像我一樣無聊了斧拍。雀扶。。

最后編輯于 ：
?著作權歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
  • 人面猴
    序言：七十年代末肆汹，一起剝皮案震驚了整個濱河市怕吴，隨后出現(xiàn)的幾起案子，更是在濱河造成了極大的恐慌县踢，老刑警劉巖转绷，帶你破解...
    沈念sama閱讀 206,311評論 6贊 481
  • 死咒
    序言：濱河連續(xù)發(fā)生了三起死亡事件，死亡現(xiàn)場離奇詭異硼啤，居然都是意外死亡议经，警方通過查閱死者的電腦和手機，發(fā)現(xiàn)死者居然都...
    沈念sama閱讀 88,339評論 2贊 382
  • 救了他兩次的神仙讓他今天三更去死
    文/潘曉璐 我一進店門，熙熙樓的掌柜王于貴愁眉苦臉地迎上來煞肾，“玉大人咧织，你說我怎么就攤上這事〖龋” “怎么了习绢？”我有些...
    開封第一講書人閱讀 152,671評論 0贊 342
  • 道士緝兇錄：失蹤的賣姜人
    文/不壞的土叔 我叫張陵，是天一觀的道長蝙昙。 經(jīng)常有香客問我闪萄，道長，這世上最難降的妖魔是什么奇颠？ 我笑而不...
    開封第一講書人閱讀 55,252評論 1贊 279
  • ?港島之戀（遺憾婚禮）
    正文 為了忘掉前任败去，我火速辦了婚禮，結(jié)果婚禮上烈拒，老公的妹妹穿的比我還像新娘圆裕。我一直安慰自己，他們只是感情好荆几，可當我...
    茶點故事閱讀 64,253評論 5贊 371
  • 惡毒庶女頂嫁案：這布局不是一般人想出來的
    文/花漫 我一把揭開白布吓妆。 她就那樣靜靜地躺著，像睡著了一般吨铸。 火紅的嫁衣襯著肌膚如雪行拢。 梳的紋絲不亂的頭發(fā)上，一...
    開封第一講書人閱讀 49,031評論 1贊 285
  • 城市分裂傳說
    那天焊傅，我揣著相機與錄音剂陡，去河邊找鬼。 笑死狐胎，一個胖子當著我的面吹牛鸭栖，可吹牛的內(nèi)容都是我干的。 我是一名探鬼主播握巢，決...
    沈念sama閱讀 38,340評論 3贊 399
  • 雙鴛鴦連環(huán)套：你想象不到人心有多黑
    文/蒼蘭香墨 我猛地睜開眼晕鹊，長吁一口氣：“原來是場噩夢啊……” “哼！你這毒婦竟也來了暴浦？” 一聲冷哼從身側(cè)響起溅话，我...
    開封第一講書人閱讀 36,973評論 0贊 259
  • 萬榮殺人案實錄
    序言：老撾萬榮一對情侶失蹤，失蹤者是張志新（化名）和其女友劉穎歌焦，沒想到半個月后飞几，有當?shù)厝嗽跇淞掷锇l(fā)現(xiàn)了一具尸體，經(jīng)...
    沈念sama閱讀 43,466評論 1贊 300
  • ?護林員之死
    正文 獨居荒郊野嶺守林人離奇死亡独撇，尸身上長有42處帶血的膿包…… 初始之章·張勛 以下內(nèi)容為張勛視角 年9月15日...
    茶點故事閱讀 35,937評論 2贊 323
  • ?白月光啟示錄
    正文 我和宋清朗相戀三年屑墨，在試婚紗的時候發(fā)現(xiàn)自己被綠了躁锁。 大學時的朋友給我發(fā)了我未婚夫和他白月光在一起吃飯的照片。...
    茶點故事閱讀 38,039評論 1贊 333
  • 活死人
    序言：一個原本活蹦亂跳的男人離奇死亡卵史，死狀恐怖战转，靈堂內(nèi)的尸體忽然破棺而出，到底是詐尸還是另有隱情以躯，我是刑警寧澤槐秧，帶...
    沈念sama閱讀 33,701評論 4贊 323
  • ?日本核電站爆炸內(nèi)幕
    正文 年R本政府宣布，位于F島的核電站忧设，受9級特大地震影響刁标，放射性物質(zhì)發(fā)生泄漏。R本人自食惡果不足惜见转，卻給世界環(huán)境...
    茶點故事閱讀 39,254評論 3贊 307
  • 男人毒藥：我在死后第九天來索命
    文/蒙蒙 一命雀、第九天 我趴在偏房一處隱蔽的房頂上張望蒜哀。 院中可真熱鬧斩箫，春花似錦、人聲如沸撵儿。這莊子的主人今日做“春日...
    開封第一講書人閱讀 30,259評論 0贊 19
  • 一樁弒父案，背后竟有這般陰謀
    文/蒼蘭香墨 我抬頭看了看天上的太陽淀歇。三九已至易核，卻和暖如春，著一層夾襖步出監(jiān)牢的瞬間浪默，已是汗流浹背牡直。 一陣腳步聲響...
    開封第一講書人閱讀 31,485評論 1贊 262
  • 情欲美人皮
    我被黑心中介騙來泰國打工， 沒想到剛下飛機就差點兒被人妖公主榨干…… 1. 我叫王不留纳决，地道東北人碰逸。 一個月前我還...
    沈念sama閱讀 45,497評論 2贊 354
  • 代替公主和親
    正文 我出身青樓，卻偏偏與公主長得像阔加，于是被迫代替她去往敵國和親饵史。 傳聞我的和親對象是個殘疾皇子，可洞房花燭夜當晚...
    茶點故事閱讀 42,786評論 2贊 345

推薦閱讀更多精彩內(nèi)容