Kotlin之“AbstractMutableList”

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

AbstractMutableList()

var modCount: Int

val Collection<*>.indices: IntRange

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

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

//如果所有的元素都符合后面指定的断言，则返回true，否则返回false
fun <T> Iterable<T>.all(predicate: (T) -> Boolean): Boolean

//如果该集合至少有一个元素就返回true，否则为false
fun <T> Iterable<T>.any(): Boolean
//如果该集合至少有一个元素符合后面指定的断言，就返回true，否则为false
fun <T> Iterable<T>.any(predicate: (T) -> Boolean): Boolean

//将该集合作为一个Iterable返回
fun <T> Iterable<T>.asIterable(): Iterable<T>

//创建一个Sequence对象包含集合的原始元素，当被遍历时返回元素
fun <T> Iterable<T>.asSequence(): Sequence<T>

//根据指定的变换方法，返回一个Map对象
fun <T, K, V> Iterable<T>.associate(transform: (T) -> Pair<K, V>): Map<K, V>

//指定返回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>

//指定返回的Map类型（必须是MutableMap类）和变换方法
fun <T, K, V, M : MutableMap<in K, in V>> Iterable<T>.associateTo(
    destination: M, 
    transform: (T) -> Pair<K, V>
): M

//指定返回的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

//使用二分搜索法搜索元素，前提元素实现了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

//使用二分搜索法找出集合中能通过selector方法和key对应上的元素位置
fun <T, K : Comparable<K>> List<T>.binarySearchBy(
    key: K?, 
    fromIndex: Int = 0, 
    toIndex: Int = size, 
    selector: (T) -> K?
): Int

//从上到下依次是返回第一个元素到返回第五个元素
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

//检查指定的元素是否包含在该集合当中
open fun contains(element: E): Boolean

//检查是否所有的元素都包含在了集合当中
fun <T> Collection<T>.containsAll(
    elements: Collection<T>
): Boolean

//返回集合中的元素符合给出的断言的个数
fun <T> Iterable<T>.count(predicate: (T) -> Boolean): Int

//去重
fun <T> Iterable<T>.distinct(): List<T>

//带去重规则的去重，这里的意思就是不根据元素本身去比较，而是用转换成的K来做去重
fun <T, K> Iterable<T>.distinctBy(
    selector: (T) -> K
): List<T>

//去掉前几个元素，如果参数n大于集合长度，那就返回一个空集合，n不能小于0,
fun <T> Iterable<T>.drop(n: Int): List<T>

//去掉后几个元素，如果参数n大于集合长度，那就返回一个空集合，n不能小于0,
fun <T> List<T>.dropLast(n: Int): List<T>

//倒序遍历集合，如果元素满足条件则去掉，直到遇到不满足判断条件的元素为止，把剩下的元素集合返回
fun <T> List<T>.dropLastWhile(
    predicate: (T) -> Boolean
): List<T>

//遍历集合，如果元素满足条件则去掉，直到遇到不满足判断条件的元素为止，把剩下的元素集合返回
fun <T> List<T>.dropWhile(
    predicate: (T) -> Boolean
): List<T>

//获取集合中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

//选出集合中符合条件的所有元素
fun <T> Iterable<T>.filter(
    predicate: (T) -> Boolean
): List<T>

//选出集合中符合条件的所有元素
fun <T> Iterable<T>.filter(
    predicate: (T) -> Boolean
): List<T>

//和filter作用一样，只是判断条件里多了一个index参数
//例如：array.filterIndexed({index, it -> index>it }).forEach(::println)
fun <T> Iterable<T>.filterIndexed(
    predicate: (index: Int, T) -> Boolean
): List<T>

//作用同filter，只是这里可以把筛选结果转换成你想要的类型C，在filterIndexed内部其实就是直接调用的它
fun <T, C : MutableCollection<in T>> Iterable<T>.filterIndexedTo(
    destination: C, 
    predicate: (index: Int, T) -> Boolean
): C

//选出集合中元素类型为R类型的所有元素集合，内部其实直接调用的是filterIsInstanceTo方法，下面会介绍
fun <R> Iterable<*>.filterIsInstance(): List<R>
//也可以这样写，两种写法，作用一样
fun <R> Iterable<*>.filterIsInstance(
    klass: Class<R>
): List<R>

//将根据类型选出来的元素放到一个指定类型的集合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

//与filter相反，这个方法筛选出所有不符合条件的元素
fun <T> Iterable<T>.filterNot(
    predicate: (T) -> Boolean
): List<T>

//顾名思义，筛选出所有非空的元素
fun <T : Any> Iterable<T?>.filterNotNull(): List<T>

//筛选出所有非空的元素并放到指定类型的集合中
fun <C : MutableCollection<in T>, T : Any> Iterable<T?>.filterNotNullTo(
    destination: C
): C

//根据指定筛选条件筛选出来的元素放入指定类型的集合中
fun <T, C : MutableCollection<in T>> Iterable<T>.filterTo(
    destination: C, 
    predicate: (T) -> Boolean
): C

//查找第一个与判断条件相符的元素，如果没有则返回null
//内部直接调用的firstOrNull方法，下面会介绍这个方法
fun <T> Iterable<T>.find(predicate: (T) -> Boolean): T?

//查找最后一个与判断条件相符的元素，如果没有则返回null
//内部直接调用的lastOrNull方法，下面会介绍这个方法
fun <T> Iterable<T>.findLast(predicate: (T) -> Boolean): T?
fun <T> List<T>.findLast(predicate: (T) -> Boolean): T?

//返回第一个符合条件的元素，注意，这里如果找不到符合条件的元素会抛出异常
//如果没找到抛出NoSuchElementException
//如果不写判断条件默认返回集合的第一个元素,注意，如果集合为空也会抛出异常
fun <T> Iterable<T>.first(predicate: (T) -> Boolean): T

//如果不写判断条件，则默认返回第一个元素，如果集合为空则返回null
//有判断条件的话则返回符合判断条件的第一个元素，没有则返回null
fun <T> List<T>.firstOrNull(): T?
fun <T> Iterable<T>.firstOrNull(): T?
fun <T> Iterable<T>.firstOrNull(predicate: (T) -> Boolean): T?

//根据指定的转换关系，将每一个元素单独做成Iterable
//最后再利用addAll()方法，将所有的新Iterable放到一个新数组里面
//内部实现是调用的flatMapTo方法，下面介绍
fun <T, R> Iterable<T>.flatMap(
    transform: (T) -> Iterable<R>
): List<R>

//像flatMap中一样，将每个元素转换成Iterable，只是这里制定了返回的集合类型
fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapTo(
    destination: C, 
    transform: (T) -> Iterable<R>
): C

//指定初始值R，之后遍历所有元素，每个元素通过指定的运算之后将结果传递到下次运算，最终把结果返回
//例如我要计算集合所有元素的和：array.fold(0,{acc, it -> it + acc }
fun <T, R> Iterable<T>.fold(
    initial: R, 
    operation: (acc: R, T) -> R
): R

//功能參考fold，这里只是在运算时多了一个元素的位置参数index
fun <T, R> Iterable<T>.foldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, T) -> R
): R

//功能參考fold，但这里是倒序，从最后一个元素开始遍历
fun <T, R> List<T>.foldRight(
    initial: R, 
    operation: (T, acc: R) -> R
): R

//功能参考foldIndexed，只是这里是倒序，从最后一个元素开始遍历
fun <T, R> List<T>.foldRightIndexed(
    initial: R, 
    operation: (index: Int, T, acc: R) -> R
): R

//遍历集合最常用的方法之一，括号里可以对每个元素进行操作
fun <T> Iterable<T>.forEach(action: (T) -> Unit)

//功能参考forEach，只是这里多了一个元素位置参数index
fun <T> Iterable<T>.forEachIndexed(
    action: (index: Int, T) -> Unit)

//获取集合中index位置的元素，如果越界了就返回默认元素，注意和elementAtOrElse区分
fun <T> List<T>.getOrElse(
    index: Int, 
    defaultValue: (Int) -> T
): T

//获取集合中index位置的元素，如果越界了就返回null
fun <T> List<T>.getOrNull(
    index: Int, 
): T

//通过指定一个规则将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>>

//功能参考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

//根据指定的keySelector创建分组，以便于之后从分组中的元素获取其分组名，也就是key
//通过调用它的keyOf方法可以获取元素的分组名也就是key
fun <T, K> Iterable<T>.groupingBy(
    keySelector: (T) -> K
): Grouping<T, K>

//返回该指定元素在集合中的第一个索引位置，如果不存在就返回-1
fun <T> Iterable<T>.indexOf(element: T): Int
fun <T> List<T>.indexOf(element: T): Int

//返回满足断言的指定元素在集合中的第一个索引位置，如果不存在就返回-1
fun <T> Iterable<T>.indexOfFirst(
    predicate: (T) -> Boolean
): Int
fun <T> List<T>.indexOfFirst(predicate: (T) -> Boolean): Int

//与indexOfFirst相反，返回满足断言的指定元素在集合中的最后一个索引位置，如果不存在就返回-1
fun <T> Iterable<T>.indexOfLast(
    predicate: (T) -> Boolean
): Int
fun <T> List<T>.indexOfLast(predicate: (T) -> Boolean): Int

//找出与指定集合中共有的元素集合（不会有重复的元素，因为是Set类型）
infix fun <T> Iterable<T>.intersect(
    other: Iterable<T>
): Set<T>

//判断集合是否不为空，其实就是内部调用！isEmpty(),
//而isEmpty()方法内部是判断的size是否等于0
fun <T> Collection<T>.isNotEmpty(): Boolean

//将集合拼接成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

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

//功能参考joinTo，这个方法只是在内部在joinTo的基础上调用了.toString()而已
fun <T> Iterable<T>.joinToString(
    separator: CharSequence = ", ", 
    prefix: CharSequence = "", 
    postfix: CharSequence = "", 
    limit: Int = -1, 
    truncated: CharSequence = "...", 
    transform: (T) -> CharSequence = null
): String

//返回集合中最后一个符合断言的元素,注意：如果找不到符合的元素会抛出异常
fun <T> Iterable<T>.last(predicate: (T) -> Boolean): T
fun <T> List<T>.last(predicate: (T) -> Boolean): T
//返回集合中最后一个元素，如果集合为空则抛出异常
fun <T> List<T>.last(): T

//返回该元素的最后一个索引位置，如果没有的话则返回-1    
fun <T> Iterable<T>.lastIndexOf(element: T): Int
fun <T> List<T>.lastIndexOf(element: T): Int

//返回集合中最后一个符合断言的元素,注意：如果找不到符合的元素则返回null
fun <T> Iterable<T>.lastOrNull(predicate: (T) -> Boolean): T?
fun <T> List<T>.lastOrNull(predicate: (T) -> Boolean): T?

//将集合所有元素根据transform进行变换，然后返回新集合，其实里面就是个for循环
fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R>

//功能参考map，只是在遍历是多一个元素位置索引参数index
fun <T, R> Iterable<T>.mapIndexed(
    transform: (index: Int, T) -> R
): List<R>

//功能参考mapIndexed，返回的集合里不包含空对象
fun <T, R : Any> Iterable<T>.mapIndexedNotNull(
    transform: (index: Int, T) -> R?
): List<R>

//在mapIndexedNotNull基础上增加了指定返回对象类型功能
fun <T, R : Any, C : MutableCollection<in R>> Iterable<T>.mapIndexedNotNullTo(
    destination: C, 
    transform: (index: Int, T) -> R?
): C

//在mapIndexed的基础上增加了指定返回对象类型的功能
fun <T, R, C : MutableCollection<in R>> Iterable<T>.mapIndexedTo(
    destination: C, 
    transform: (index: Int, T) -> R
): C

//在map的基础上过滤掉了null元素对象  
fun <T, R : Any> Iterable<T>.mapNotNull(
    transform: (T) -> R?
): List<R>

//在mapNotNull的基础上增加了指定返回对象类型的功能
fun <T, R : Any, C : MutableCollection<in R>> Iterable<T>.mapNotNullTo(
    destination: C, 
    transform: (T) -> R?
): C

//在map的基础上增加了指定返回对象类型的功能
fun <T, R, C : MutableCollection<in R>> Iterable<T>.mapTo(
    destination: C, 
    transform: (T) -> R
): C

//返回集合中最大的元素，前提是元素得实现Comparable接口，如果集合为空则返回null
fun <T : Comparable<T>> Iterable<T>.max(): T?

//对集合中的每个元素进行转换之后比值，返回转换后的值最大的元素，如果集合为空则返回null
fun <T, R : Comparable<R>> Iterable<T>.maxBy(
    selector: (T) -> R
): T?

//根据指定的比较规则，来选出集合中最大的元素
fun <T> Iterable<T>.maxWith(comparator: Comparator<in T>): T?
fun <T> Iterable<T>.maxWith(comparator: Comparator<in T>): T?

//去掉集合中指定的元素,如果集合中有多个这元素，则只去掉第一个
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>

//作用同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>)

//内部直接调用的minus
fun <T> Iterable<T>.minusElement(element: T): List<T>

//如果集合中没有元素则返回true  
fun <T> Iterable<T>.none(): Boolean
//如果集合中没有符合断言的元素则返回true
fun <T> Iterable<T>.none(predicate: (T) -> Boolean): Boolean

//将集合根据断言分成两个集合，并组成Pair对象，第一个List是符合断言的所有元素，第二个是剩下的
fun <T> Iterable<T>.partition(
    predicate: (T) -> Boolean
): Pair<List<T>, List<T>>

//将指定元素放到该集合中
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>

//作用参考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>)

//作用参考plus
fun <T> Iterable<T>.plusElement(element: T): List<T>
fun <T> Collection<T>.plusElement(element: T): List<T>

//遍历所有元素，每个元素通过指定的运算之后将结果传递到下次运算，最终把结果返回
//注意和fold()的区别，这个方法没有设置初始值
fun <S, T : S> Iterable<T>.reduce(
    operation: (acc: S, T) -> S
): S

//功能参考reduce，只是在指定运算方法时多了个参数index   
fun <S, T : S> Iterable<T>.reduceIndexed(
    operation: (index: Int, acc: S, T) -> S
): S

//倒序遍历的reduce
fun <S, T : S> List<T>.reduceRight(
    operation: (T, acc: S) -> S
): S

//倒序遍历的reduceIndexed
fun <S, T : S> List<T>.reduceRightIndexed(
    operation: (index: Int, T, acc: S) -> S
): S

//反转集合中的元素顺序
fun <T> MutableList<T>.reverse()

//将反转之后的集合返回
fun <T> Iterable<T>.reversed(): List<T>

//如果集合为空则抛出异常，如果集合里只有一个元素，则返回这个元素，如果多于一个元素则抛出异常
fun <T> List<T>.single(): T
//返回唯一满足条件的元素，如果没有找到或集合为空或找到多个都会抛出异常
fun <T> Iterable<T>.single(predicate: (T) -> Boolean): T

//如果找到一个满足条件的元素则返回这个元素，其他所有情况均返回null
fun <T> Iterable<T>.singleOrNull(
    predicate: (T) -> Boolean
): T?

//指定一个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>

//自然排序
fun <T : Comparable<T>> MutableList<T>.sort()

//根据指定转换规则转换后的元素进行自然排序
fun <T, R : Comparable<R>> MutableList<T>.sortBy(
    selector: (T) -> R?)

//根据指定转换规则转换后的元素进行自然倒序排序
fun <T, R : Comparable<R>> MutableList<T>.sortByDescending(
    selector: (T) -> R?)

//自然倒序排序
fun <T : Comparable<T>> MutableList<T>.sortDescending()

//根据指定比较规则进行排序
fun <T> MutableList<T>.sortWith(comparator: Comparator<in T>)
fun <T> MutableList<T>.sortWith(comparator: Comparator<in T>)

//返回自然排序的结果
fun <T : Comparable<T>> Iterable<T>.sorted(): List<T>

//根据指定规则转换后的元素进行自然排序，然后把返回排序结果
fun <T, R : Comparable<R>> Iterable<T>.sortedBy(
    selector: (T) -> R?
): List<T>

//参考sortByDescending，只是这个方法会返回排序结果
fun <T, R : Comparable<R>> Iterable<T>.sortedByDescending(
    selector: (T) -> R?
): List<T>

//根据指定的比较规则进行排序，并返回排序结果 
fun <T> Iterable<T>.sortedWith(
    comparator: Comparator<in T>
): List<T>
fun <T> Iterable<T>.sortedWith(
    comparator: Comparator<in T>
): List<T>

//返回一个Set集合，其中包含此集合的所有元素，除了指定集合中的元素
infix fun <T> Iterable<T>.subtract(
    other: Iterable<T>
): Set<T>

//将集合中所有元素根据指定转换规则转换的结果进行求和
fun <T> Iterable<T>.sumBy(selector: (T) -> Int): Int

//参考sumBy，只是返回的结果为double类型
fun <T> Iterable<T>.sumByDouble(
    selector: (T) -> Double
): Double

//返回包含前n个元素的集合
fun <T> Iterable<T>.take(n: Int): List<T>

//返回包含后n个元素的集合  
fun <T> List<T>.takeLast(n: Int): List<T>

//正序遍历集合，将满足条件的元素放入新集合并返回，
//直到遇见不符合条件的元素结束，后面的元素就算满足条件也不会被加入新集合
fun <T> Iterable<T>.takeWhile(
    predicate: (T) -> Boolean
): List<T>

//倒序遍历集合，将满足条件的元素放入新集合并返回，
//直到遇见不符合条件的元素结束，后面的元素就算满足条件也不会被加入新集合
fun <T> List<T>.takeLastWhile(
    predicate: (T) -> Boolean
): List<T>

//返回一个set，包含这两个集合的所有元素，并且对元素去重
infix fun <T> Iterable<T>.union(other: Iterable<T>): Set<T>

//返回一个包含所有元素的indexedValue的懒加载集合
fun <T> Iterable<T>.withIndex(): Iterable<IndexedValue<T>>

//将两个集合按顺序取出元素，相同位置的两个元素组成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>