Kotlin之“AbstractMutableList”

简介

AbstractMutableList 是一个超级好用的抽象类，里面实现了好多对集合操作的直观方法，新鲜事物基本就体现在这里。哪怕是暂时用不到，至少也得先看看有些啥，能干点啥吧。

出身

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

AbstractMutableList实现了两个接口，其中：

  • MutableList 使得它的集合长度可变，该接口不提供管理容量大小的方法，像js中的array一样自动改变大小
  • AbstractList 定义了一般List的方法结构，也就是说所有的List都必须有的方法，比如需要实现一个容量不可变的数组，直接实现这个接口，并提供get(Int)和size()方法就可以了

构造方法（Constructors）

  • 提供MutableList接口的原始实现框架
AbstractMutableList()

参数

  • modCount 继承来的参数，js中表示该集合的结构变化次数
var modCount: Int

原始方法和继承来的方法（参照ArrayList ）

扩展参数

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
//创建一个Sequence对象包含集合的原始元素，当被遍历时返回元素
fun <T> Iterable<T>.asSequence(): Sequence<T>
  • associate
//根据指定的变换方法，返回一个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（如果结果有多个，不保证返回的是哪一个结果的位置）
//使用二分搜索法搜索元素，前提元素实现了Comparable接口，查找范围默认为整个集合，可以不指定
fun <T : Comparable<T>> List<T?>.binarySearch(
    element: T?, 
    fromIndex: Int = 0, 
    toIndex: Int = size
): Int
//如果元素没有实现Comparable接口，也可以在这里指定
fun <T> List<T>.binarySearch(
    element: T, 
    comparator: Comparator<in T>, 
    fromIndex: Int = 0, 
    toIndex: Int = size
): Int
//不写具体的某个元素，根据comparison也能找出结果，是通过判断comparison的结果是否为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
//返回集合中的元素符合给出的断言的个数
fun <T> Iterable<T>.count(predicate: (T) -> Boolean): Int
  • distinct
//去重
fun <T> Iterable<T>.distinct(): List<T>
  • distinctBy
//带去重规则的去重，这里的意思就是不根据元素本身去比较，而是用转换成的K来做去重
fun <T, K> Iterable<T>.distinctBy(
    selector: (T) -> K
): List<T>
  • drop
//去掉前几个元素，如果参数n大于集合长度，那就返回一个空集合，n不能小于0,
fun <T> Iterable<T>.drop(n: Int): List<T>
  • dropLast
//去掉后几个元素，如果参数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，那么就相当于直接调用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参数
//例如：array.filterIndexed({index, it -> index>it }).forEach(::println)
fun <T> Iterable<T>.filterIndexed(
    predicate: (index: Int, T) -> Boolean
): List<T>
  • filterIndexedTo
//作用同filter，只是这里可以把筛选结果转换成你想要的类型C，在filterIndexed内部其实就是直接调用的它
fun <T, C : MutableCollection<in T>> Iterable<T>.filterIndexedTo(
    destination: C, 
    predicate: (index: Int, T) -> Boolean
): C
  • filterIsInstance
//选出集合中元素类型为R类型的所有元素集合，内部其实直接调用的是filterIsInstanceTo方法，下面会介绍
fun <R> Iterable<*>.filterIsInstance(): List<R>
//也可以这样写，两种写法，作用一样
fun <R> Iterable<*>.filterIsInstance(
    klass: Class<R>
): List<R>
  • filterIsInstanceTo
//将根据类型选出来的元素放到一个指定类型的集合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
//根据指定筛选条件筛选出来的元素放入指定类型的集合中
fun <T, C : MutableCollection<in T>> Iterable<T>.filterTo(
    destination: C, 
    predicate: (T) -> Boolean
): C
  • find（注意和filter的区分）
//查找第一个与判断条件相符的元素，如果没有则返回null
//内部直接调用的firstOrNull方法，下面会介绍这个方法
fun <T> Iterable<T>.find(predicate: (T) -> Boolean): T?
  • findLast
//查找最后一个与判断条件相符的元素，如果没有则返回null
//内部直接调用的lastOrNull方法，下面会介绍这个方法
fun <T> Iterable<T>.findLast(predicate: (T) -> Boolean): T?
fun <T> List<T>.findLast(predicate: (T) -> Boolean): T?
  • first（注意和find的区分）
//返回第一个符合条件的元素，注意，这里如果找不到符合条件的元素会抛出异常
//如果没找到抛出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
//根据指定的转换关系，将每一个元素单独做成Iterable
//最后再利用addAll()方法，将所有的新Iterable放到一个新数组里面
//内部实现是调用的flatMapTo方法，下面介绍
fun <T, R> Iterable<T>.flatMap(
    transform: (T) -> Iterable<R>
): List<R>
  • flatMapTo
//像flatMap中一样，将每个元素转换成Iterable，只是这里制定了返回的集合类型
fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapTo(
    destination: C, 
    transform: (T) -> Iterable<R>
): C
  • fold
//指定初始值R，之后遍历所有元素，每个元素通过指定的运算之后将结果传递到下次运算，最终把结果返回
//例如我要计算集合所有元素的和：array.fold(0,{acc, it -> it + acc }
fun <T, R> Iterable<T>.fold(
    initial: R, 
    operation: (acc: R, T) -> R
): R
  • foldIndexed
//功能參考fold，这里只是在运算时多了一个元素的位置参数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，只是这里多了一个元素位置参数index
fun <T> Iterable<T>.forEachIndexed(
    action: (index: Int, T) -> Unit)
  • getOrElse
//获取集合中index位置的元素，如果越界了就返回默认元素，注意和elementAtOrElse区分
fun <T> List<T>.getOrElse(
    index: Int, 
    defaultValue: (Int) -> T
): T
  • getOrNull
//获取集合中index位置的元素，如果越界了就返回null
fun <T> List<T>.getOrNull(
    index: Int, 
): T
  • groupBy
//通过指定一个规则将list进行分组，将结果整合成Map，Map的key则根据keySelector指定
//内部实现直接调用groupByTo方法，返回类型默认，下面会有介绍
fun <T, K> Iterable<T>.groupBy(
    keySelector: (T) -> K
): Map<K, List<T>>
//当然如果指定了value的变化规则，那么最后Map中的list的元素也将可以根据规则指定
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版本方法）
//根据指定的keySelector创建分组，以便于之后从分组中的元素获取其分组名，也就是key
//通过调用它的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
//判断集合是否不为空，其实就是内部调用！isEmpty(),
//而isEmpty()方法内部是判断的size是否等于0
fun <T> Collection<T>.isNotEmpty(): Boolean
  • joinTo
//将集合拼接成buffer
fun <T, A> Iterable<T>.joinTo(
    buffer: A, //buffer对象
    separator: CharSequence = ", ", //分割用的，默认是逗号
    prefix: CharSequence = "", //拼在开头部分的内容
    postfix: CharSequence = "", //拼在结尾部分的内容
    limit: Int = -1, //要拼的元素个数，默认为-1，就是没有任何限制，把所有的元素都拼上
    truncated: CharSequence = "...", //如果集合中元素个数大于limit值，则在后面拼上truncated，默认是三个点
    transform: (T) -> CharSequence = null//集合中元素的转换方式
): A

假设我有一个包含数字1~6的集合，我要把他们拼一下：

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

打印结果分别为
prefix1:2:3:4:5:6postfix
prefix1:2:3:truncatedpostfix

  • joinToString
//功能参考joinTo，这个方法只是在内部在joinTo的基础上调用了.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
//将集合所有元素根据transform进行变换，然后返回新集合，其实里面就是个for循环
fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R>
  • mapIndexed
//功能参考map，只是在遍历是多一个元素位置索引参数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
//返回集合中最大的元素，前提是元素得实现Comparable接口，如果集合为空则返回null
fun <T : Comparable<T>> Iterable<T>.max(): T?
  • maxBy
//对集合中的每个元素进行转换之后比值，返回转换后的值最大的元素，如果集合为空则返回null
fun <T, R : Comparable<R>> Iterable<T>.maxBy(
    selector: (T) -> R
): T?
  • maxWith
//根据指定的比较规则，来选出集合中最大的元素
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，内部直接调用remove()方法，注意与minus的区别，这个没有返回值
operator fun <T> MutableCollection<in T>.minusAssign(element: T)
//作用同minus，内部直接调用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
//内部直接调用的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
//将集合根据断言分成两个集合，并组成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
//遍历所有元素，每个元素通过指定的运算之后将结果传递到下次运算，最终把结果返回
//注意和fold()的区别，这个方法没有设置初始值
fun <S, T : S> Iterable<T>.reduce(
    operation: (acc: S, T) -> S
): S
  • reduceIndexed
//功能参考reduce，只是在指定运算方法时多了个参数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
//反转集合中的元素顺序
fun <T> MutableList<T>.reverse()
  • reversed
//将反转之后的集合返回
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区间，然后根据这个int区间去调用subList()方法   ,如果没指定区间则返回空集合
//：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
//根据指定转换规则转换后的元素进行自然排序
fun <T, R : Comparable<R>> MutableList<T>.sortBy(
    selector: (T) -> R?)
  • sortByDescending
//根据指定转换规则转换后的元素进行自然倒序排序
fun <T, R : Comparable<R>> MutableList<T>.sortByDescending(
    selector: (T) -> R?)
  • sortDescending
//自然倒序排序
fun <T : Comparable<T>> MutableList<T>.sortDescending()
  • sortWith
//根据指定比较规则进行排序
fun <T> MutableList<T>.sortWith(comparator: Comparator<in T>)
fun <T> MutableList<T>.sortWith(comparator: Comparator<in T>)
  • sorted
//返回自然排序的结果
fun <T : Comparable<T>> Iterable<T>.sorted(): List<T>
  • sortedBy
//根据指定规则转换后的元素进行自然排序，然后把返回排序结果
fun <T, R : Comparable<R>> Iterable<T>.sortedBy(
    selector: (T) -> R?
): List<T>
  • sortedByDescending
//参考sortByDescending，只是这个方法会返回排序结果
fun <T, R : Comparable<R>> Iterable<T>.sortedByDescending(
    selector: (T) -> R?
): List<T>
  • sortedWith
//根据指定的比较规则进行排序，并返回排序结果 
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
//将集合中所有元素根据指定转换规则转换的结果进行求和
fun <T> Iterable<T>.sumBy(selector: (T) -> Int): Int
  • sumByDouble
//参考sumBy，只是返回的结果为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
//正序遍历集合，将满足条件的元素放入新集合并返回，
//直到遇见不符合条件的元素结束，后面的元素就算满足条件也不会被加入新集合
fun <T> Iterable<T>.takeWhile(
    predicate: (T) -> Boolean
): List<T>
  • takeLastWhile
//倒序遍历集合，将满足条件的元素放入新集合并返回，
//直到遇见不符合条件的元素结束，后面的元素就算满足条件也不会被加入新集合
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>>
//将两个集合按顺序取出元素，相同位置的两个元素按指定转换规则转换，并将结果保存到新集合中返回，
//如果两个集合长度不一样，以短的为准 
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>

总结

到这里所有的AbstractMutableList的神奇方法都已经介绍完毕了，感觉不会有人能像我一样无聊了。。。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 160,504评论 4赞 365
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 67,898评论 1赞 300
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 110,218评论 0赞 248
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 44,322评论 0赞 214
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 52,693评论 3赞 290
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 40,812评论 1赞 223
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 32,010评论 2赞 315
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 30,747评论 0赞 204
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 34,476评论 1赞 246
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 30,700评论 2赞 251
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 32,190评论 1赞 262
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 28,541评论 3赞 258
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 33,206评论 3赞 240
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 26,129评论 0赞 8
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,903评论 0赞 199
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 35,894评论 2赞 283
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 35,748评论 2赞 274

推荐阅读更多精彩内容