kotlin集合遍历和集合操作符

1，kotlin集合的遍历，有以下几种方式：

1，用..关键字，包含右边界
for (i in 1..10) {
    //print 1  2  3  4  5  6  7  8  9  10
    print("  $i")
}
2，用until关键字，不包含右边界
for (i in 1 until 10) {
    //print 1  2  3  4  5  6  7  8  9
    print("  $i")
}
3，用downTo关键字，将遍历方向变为从高到低
for (i in 10 downTo 1) {
    //print 10  9  8  7  6  5  4  3  2  1
    print("  $i")
}
4，通过step去跳着遍历
for (i in 1..10 step 2) {
    //print 1  3  5  7  9
    print("  $i")
}
5，是一个重复次数的函数，也可以当作遍历来看待
repeat(10) {
    //print 0  1  2  3  4  5  6  7  8  9
    print("  $it")
}
val list = arrayListOf<String>("1", "2", "3", "4", "5", "6", "7", "8")
6，通过in关键字遍历
for (str in list) {
    //print str = 1  |  str = 2  |  str = 3  |  str = 4  |  str = 5  |  str = 6  |  str = 7  |  str = 8  |
    print("str = $str  |  ")
}
7，通过in关键字和withIndex()函数遍历，获取集合索引和集合值
for ((index, str) in list.withIndex()) {
    //print  index = 0   str 1  | index = 1   str 2  | index = 2   str 3  | index = 3   str 4  | index = 4   str 5  | index = 5   str 6  | index = 6   str 7  | index = 7   str 8  |
    print("index = $index   str $str  | ")
}
复制代码

2，集合操作符

filter：筛选出指定条件的元素
map：将筛选出来的元素进行指定条件的值的转换
reduce：合并上一次的结果和当前的结果

val listStr = arrayOf("a", "p", "5", "9", "g", "k", "0")
val listInt = arrayOf(4, 7, 1, 3, 7, 9, 0, 2)

fun main(args: Array<String>) {
    listInt.filter {
        //筛选出listInt中比listStr.size小的元素
        it < listStr.size
    }.map {
        //通过筛选出来的元素获取listStr中对应索引的值
        listStr[it]
    }.reduce { acc, i ->
        // print acc=g  i=p |  acc=gp  i=9 |  acc=gp9  i=a |  acc=gp9a  i=5 |
        print(" acc=$acc  i=$i | ")
        //合并，将acc和i合并为一个值
        "$acc$i"
    }.also {
        println("it  $it")
    }
}

复制代码

3，自定义操作符

下面的代码，自定义了一个集合相关的convert操作符，将list中的每个元素 + 1

fun main(args: Array<String>) {
    action()
}
fun action() {
    val list = listOf(1, 2, 3, 4, 5, 6, 7)
    //print 2 3 4 5 6 7 8
    list.convert { it + 1 }.forEach { print(it) }
}

/**
 * 内联扩展函数，扩展的是Iterable，
 * 集合的顶层是“public interface Collection<out E> : Iterable<E>”，
 * 即集合都实现了Iterable接口，所以扩展Iterable就意味着所有集合都可以用自定义的扩展函数convert
 */
inline fun <T, E> Iterable<T>.convert(action: (T) -> E): Iterable<E> {
    //定义一个可变的list
    val list: MutableList<E> = mutableListOf()
    //循环遍历调用扩展函数convert的集合
    for (item: T in this)
        //将修改后的value，add到定义的可变的list中
        list.add(action(item))
        //返回定义的可变list
    return list
}

复制代码