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的神奇方法都已经介绍完毕了,感觉不会有人能像我一样无聊了。。。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏WindCoder

Java漫谈-数组

在Java语言中,数组是对象(An object is a class instance or an array.),而且是动态创建的。

1521
来自专栏程序员的知识天地

python 实现各种排序算法

归并排序也称合并排序,是分治法的典型应用。分治思想是将每个问题分解成个个小问题,将每个小问题解决,然后合并。

781
来自专栏企鹅号快讯

Python网络爬虫之正则表达式

正则表达式非Python独有,在Python中通过re库模块实现。 ? 下面是一些常见的匹配模式 ? re.match re.match尝试从字符串的起始位置匹...

18610
来自专栏闻道于事

Java之集合的遍历与迭代器

集合的遍历 依次获取集合中的每一个元素 将集合转换成数组,遍历数组 //取出所有的学号, 迭代之后显示学号为1004-1009 Object[]...

3505
来自专栏陈树义

《JavaScript程序设计》第2课:JS类型系统

JS类型系统可以分为标准类型和对象类型,进一步标准类型又可以分为原始类型和引用类型,而对象类型又可以分为内置对象类型、普通对象类型、自定义对象类型。 ? 1. ...

3377
来自专栏cs

归并排序

归并排序,采用分治法。首先采用递归,把数组分成一小段有序,然后再把有序的数组一一合并。 首先看看,把有序的二个数组,合成一个的算法。 package day20...

2434
来自专栏浪淘沙

Java学习day09

2018.6.13 1.增强for循环 //第一个参数是 获得的数据 //第二个是 数组或集合

1143
来自专栏深度学习之tensorflow实战篇

hive字符串函数

hive字符串函数 1. 字符串长度函数:length 语法: length(string A) 返回值: int 说明:返回字符串A的长度 举例:hive> ...

7757
来自专栏Java与Android技术栈

Scala学习笔记(六)

偏函数(Partial Function),是一个数学概念它不是"函数"的一种, 它跟函数是平行的概念。 Scala中的Partia Function是一个T...

862
来自专栏互联网杂技

javascript大法好,不用记

数组的操作 ---- Array.prototype.toString ( ) 把数组转变为字符串,返回字符串,arr.toString(); ---- Arr...

3677

扫码关注云+社区

领取腾讯云代金券