Kotlin - API

常用API

contains(元素) : 检查集合中是否包含指定的元素，若存在则返回true，反之返回false
elementAt(index) : 获取对应下标的元素。若下标越界，会抛IndexOutOfBoundsException（下标越界）异常，同get(index)一样
elementAtOrElse(index,{...}) : 获取对应下标的元素。若下标越界，返回默认值，此默认值就是你传入的下标的运算值
elementAtOrNull(index) : 获取对应下标的元素。若下标越界，返回null
first() : 获取第一个元素，若集合为空集合，这会抛出NoSuchElementException异常
first{} : 获取指定元素的第一个元素。若不满足条件，则抛出NoSuchElementException异常
firstOrNull() : 获取第一个元素，若集合为空集合，返回null
firstOrNull{} : 获取指定元素的第一个元素。若不满足条件，返回null
getOrElse(index,{...}) : 同elementAtOrElse一样
getOrNull(index) : 同elementAtOrNull一样
last() : 同first()相反
last{} : 同first{}相反
lastOrNull{} : 同firstOrNull()相反
lastOrNull() : 同firstOrNull{}相反
indexOf(元素) : 返回指定元素的下标，若不存在，则返回-1
indexOfFirst{...} : 返回第一个满足条件元素的下标，若不存在，则返回-1
indexOfLast{...} : 返回最后一个满足条件元素的下标，若不存在，则返回-1
single() : 若集合的长度等于0,则抛出NoSuchElementException异常，若等于1，则返回第一个元素。反之，则抛出IllegalArgumentException异常
single{} : 找到集合中满足条件的元素，若元素满足条件，则返回该元素。否则会根据不同的条件，抛出异常。这个方法慎用
singleOrNull() : 若集合的长度等于1,则返回第一个元素。否则，返回null
singleOrNull{} : 找到集合中满足条件的元素，若元素满足条件，则返回该元素。否则返回null
forEach{...} : 遍历元素。一般用作元素的打印
forEachIndexed{index,value} : 遍历元素，可获得集合中元素的下标。一般用作元素以及下标的打印
componentX() ： 这个函数在前面的章节中提过多次了。用于获取元素。其中的X只能代表1..5。详情可看下面的例子

reversed() : 反序。即和初始化的顺序反过来。
sorted() : 自然升序。
sortedBy{} : 根据条件升序，即把不满足条件的放在前面，满足条件的放在后面
sortedDescending() : 自然降序。
sortedByDescending{} : 根据条件降序。和sortedBy{}相反

filter{...} : 把不满足条件的元素过滤掉
filterIndexed{...} : 和filter{}函数作用类似，只是可以操作集合中元素的下标（index）
filterNot{...} : 和filter{}函数的作用相反
filterNotNull() : 过滤掉集合中为null的元素。
take(num) : 返回集合中前num个元素组成的集合
takeWhile{...} : 循环遍历集合，从第一个元素开始遍历集合，当第一个出现不满足条件元素的时候，退出遍历。然后把满足条件所有元素组成的集合返回。
takeLast(num) : 返回集合中后num个元素组成的集合
takeLastWhile{...} : 循环遍历集合，从最后一个元素开始遍历集合，当第一个出现不满足条件元素的时候，退出遍历。然后把满足条件所有元素组成的集合返回。
drop(num) : 过滤集合中前num个元素
dropWhile{...} : 相同条件下，和执行takeWhile{...}函数后得到的结果相反
dropLast(num) : 过滤集合中后num个元素
dropLastWhile{...} : 相同条件下，和执行takeLastWhile{...}函数后得到的结果相反
distinct() : 去除重复元素
distinctBy{...} : 根据操作元素后的结果去除重复元素
slice : 过滤掉所有不满足执行下标的元素。

any() : 判断是不是一个集合，若是，则在判断集合是否为空，若为空则返回false,反之返回true,若不是集合，则返回hasNext
any{...} : 判断集合中是否存在满足条件的元素。若存在则返回true,反之返回false
all{...} : 判断集合中的所有元素是否都满足条件。若是则返回true,反之则返回false
none() : 和any()函数的作用相反
none{...} : 和all{...}函数的作用相反
max() : 获取集合中最大的元素，若为空元素集合，则返回null
maxBy{...} : 获取方法处理后返回结果最大值对应那个元素的初始值，如果没有则返回null
min() : 获取集合中最小的元素，若为空元素集合，则返回null
minBy{...} : 获取方法处理后返回结果最小值对应那个元素的初始值，如果没有则返回null
sum() : 计算出集合元素累加的结果。
sumBy{...} : 根据元素运算操作后的结果，然后根据这个结果计算出累加的值。
sumByDouble{...} : 和sumBy{}相似，不过sumBy{}是操作Int类型数据，而sumByDouble{}操作的是Double类型数据
average() : 获取平均数
reduce{...} : 从集合中的第一项到最后一项的累计操作。
reduceIndexed{...} : 和reduce{}作用相同，只是其可以操作元素的下标(index)
reduceRight{...} : 从集合中的最后一项到第一项的累计操作。
reduceRightIndexed{...} : 和reduceRight{}作用相同，只是其可以操作元素的下标(index)
fold{...} : 和reduce{}类似，但是fold{}有一个初始值
foldIndexed{...} : 和reduceIndexed{}类似，但是foldIndexed{}有一个初始值
foldRight{...} : 和reduceRight{}类似，但是foldRight{}有一个初始值
foldRightIndexed{...} : 和reduceRightIndexed{}类似，但是foldRightIndexed{}有一个初始值

take、drop方法使用

take

• 1、take方法：

private fun take() {
    val mList = mutableListOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
    //take函数是根据传入的参数挑出该集合【前n个元素】的子集合
    val mNewList1 = mList.take(2)
    println(mNewList1)
    //[1, 2]

    //takeLast函数是根据传入的参数挑出该集合【倒数n个元素】的子集合
    val mNewList2 = mList.takeLast(2)
    println(mNewList2)
    //[9, 0]
}

• 2、takeWhile

private fun takeWhile() {
    val mList = mutableListOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 0)

    //takeWhile : 从头开始取值，不符合立即停止
    val mNewList3 = mList.takeWhile {
        it % 2 == 0
    }
    println(mNewList3)
    //[]


    //takeLastWhile : 从尾开始取值，不符合立即停止
    val mNewList4 = mList.takeLastWhile {
        it % 2 == 0
    }
    println(mNewList4)
    //[0]
}

• 3、 takeIf

private fun takeIf() {
    val mList = mutableListOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 0)

    //如果符合返回它
    val mNewList5 = mList.takeIf {
        it.size == 10 //true
    }
    println(mNewList5)
    //[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]


    val mNewList51 = mList.takeIf {
        it.size == 5  //false
    }
    println(mNewList51)
    //null
}

• 4、 takeUnless

private fun takeUnless() {
    val mList = mutableListOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 0)

    //如果不符合返回它
    val mNewList6 = mList.takeUnless {
        it.size == 10  //true
    }
    println(mNewList6)
    //null


    val mNewList61 = mList.takeUnless {
        it.size == 5  //false
    }
    println(mNewList61)
    //[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]

}

drop

• 1、 drop

private fun drop() {
    //去掉前n个开始取值
    val mList = mutableListOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
    val resultList = mList.drop(3)
    println(resultList)
}
//[4, 5, 6, 7, 8, 9, 0]

• 2、 dropLast

private fun dropLast() {
    //去掉最后n个开始取值
    val mList = mutableListOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
    val resultList = mList.dropLast(3)
    println(resultList)
}
//[1, 2, 3, 4, 5, 6, 7]

• 3、dropLastWhile

private fun dropWhile() {
    //从头开始找不满足的开始取值，满足的抛弃头部
    val mList = mutableListOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
    val resultList = mList.dropWhile { it <= 1 }
    println(resultList)
}
//[2, 3, 4, 5, 6, 7, 8, 9, 0]