Kotlin——高级篇（五）：集合之常用操作符汇总

喜欢ヅ旅行 2022-05-21 09:08 255阅读 0赞

## 目录 ##

![1][]

## 一、转换类 ##

在上一篇文章中讲解数组(`Array<T>`)的与集合的时候也提到了关于集合转换的高阶函数。下面用源码的角度去分析并用实例去讲解其转换的过程。

### 1.1、转换为数组 ###

> 当我们声明一个集合，可以把这个集合根据调用集合类相应的高阶函数来转换成相应的数组。集合类提供了`toIntArray()`、`toDoubleArray()`、`toFloatArray()`、`toBetArray()`等高阶函数去处理。下面提供一个函数的源码，其他函数的源码处理逻辑是相同的，有兴趣的朋友可以去看看这个源码类。

源码：

public fun Collection<Int>.toIntArray(): IntArray {
        val result = IntArray(size)
        var index = 0
        for (element in this)
            result[index++] = element
        return result
    }

解释：从上面的源码，我们可以看出，该函数的返回类型时`IntArray`类型,即表示一个`Int`类型的数组。该函数的逻辑是定义一个`Int`类型的数组，然后遍历集合，把集合的元素一个一个的添加到定义的数组当中。

实例：

fun listToArray(){
        val list = listOf<Int>(1,2,3,4,5,6)         // 声明一个Int类型的List
        val listArray = list.toIntArray()           // 转换
    
        println(list.javaClass.toString())          // 打印list的类型
        println(listArray.javaClass.toString())     // 打印listArray的类型
        println(listArray[1])
    }

输出结果：

变量list的类型为：class java.util.LinkedHashSet
    变量listArray的类型为：class [I
    2

### 1.2、转换为集合 ###

> 我们知道在`Kotlin`中，集合可分为不可变集合与可变集合。我们声明一个集合或者数组，可以转换成相应类型的集合。调用`toXXX()`转换成不可变集合。调用`toMutableXXX()`转换为可变集合。集合类提供了`toList()`、`toMutableList()`、`toSet()`、`toMutableSet()`、`toHashSet()`、`toMap()`等高阶函数去处理。同理也是从源码的角度去分析。

源码：这个是集合转集合的源码。数组转集合的源码还要简单些。

public fun <T> Iterable<T>.toList(): List<T> {
        if (this is Collection) {
            return when (size) {
                0 -> emptyList()
                1 -> listOf(if (this is List) get(0) else iterator().next())
                else -> this.toMutableList()
            }
        }
        return this.toMutableList().optimizeReadOnlyList()
    }

解释：首先判断是不是一个集合，如果是一个集合的情况，则根据集合的元素个数来执行相应的逻辑，当元素的个数为`0`时，返回一个空集合。当为`1`个的时候，用`listOf()`去初始化一个`List`集合。在这个新集合中去这个判断原集合的类型是不是返回集合的类型，如果是，则获取原集合的第一个元素作为新集合的元素返回。反之，则遍历原集合的元素。当原集合个数不为`0`或`1`时，使用`toMutableList()`转换成list。如果不是集合，则直接使用`toMutableList()`转换。这里的`optimizeReadOnlyList()`函数的逻辑即是上面原集合的逻辑。

解释起来很复杂，还是用代码说话吧...

实例：

// 数组转集合
    fun arrayToList() {
        val arr = arrayOf(1,3,5,7,9)
        val list = arr.toList()
        println("变量arr的类型为：${arr.javaClass}")
        println("变量list的类型为：${list.javaClass}")
        println(list[1])
    }
    
    // 集合转集合，这里用Set转List
    
    fun listToList(){
        val set = setOf(1)
        val setTolist = set.toList()
        
        println("变量set的类型为：${set.javaClass}")
        println("变量setTolist的类型为：${setTolist.javaClass}")
        println(setTolist[0])
    }

输出结果为：

变量arr的类型为：class [Ljava.lang.Integer;
    变量list的类型为：class java.util.ArrayList
    3
    
    变量set的类型为：class java.util.Collections$SingletonSet
    变量setTolist的类型为：class java.util.Collections$SingletonList
    1

关于集合转换的问题就讲到这里，有兴趣的同学可以去看看源码的实现。

## 二、操作类 ##

关于集合操作类的函数大致分为六类，他们几乎上囊括了源码中实现的操作方法。下面对这`6`类操作符进行一一的讲解，不过这里就不对他们的源码进行分析了。大家有兴趣的话可以去看看他们的源码实现。几乎上都存在于`_Collections.kt`这个文件中

### 2.1、元素操作符 ###

元素操作符在这里包括：

>  *  `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`。详情可看下面的例子

例：

val list = listOf("kotlin","Android","Java","PHP","Python","IOS")
    
    println("  ------   contains -------")
    println(list.contains("JS"))
    
    println("  ------   elementAt -------")
    
    println(list.elementAt(2))
    println(list.elementAtOrElse(10,{it}))
    println(list.elementAtOrNull(10))
    
    println("  ------   get -------")
    println(list.get(2))
    println(list.getOrElse(10,{it}))
    println(list.getOrNull(10))
    
    println("  ------   first -------")
    println(list.first())
    println(list.first{ it == "Android" })
    println(list.firstOrNull())
    println(list.firstOrNull { it == "Android" })
    
    println("  ------   last -------")
    println(list.last())
    println(list.last{ it == "Android" })
    println(list.lastOrNull())
    println(list.lastOrNull { it == "Android" })
    
    println("  ------   indexOf -------")
    println(list.indexOf("Android"))
    println(list.indexOfFirst { it == "Android" })
    println(list.indexOfLast { it == "Android" })
    
    println("  ------   single -------")
    val list2 = listOf("list")
    println(list2.single())     // 只有当集合只有一个元素时，才去用这个函数，不然都会抛出异常。
    println(list2.single { it == "list" }) //当集合中的元素满足条件时，才去用这个函数，不然都会抛出异常。若满足条件返回该元素
    println(list2.singleOrNull()) // 只有当集合只有一个元素时，才去用这个函数，不然都会返回null。
    println(list2.singleOrNull { it == "list" }) //当集合中的元素满足条件时，才去用这个函数，不然返回null。若满足条件返回该元素
    
    println("  ------   forEach -------")
    list.forEach { println(it) }
    list.forEachIndexed { index, it -> println("index : $index \t value = $it") }
    
    println("  ------   componentX -------")
    println(list.component1())  // 等价于`list[0]  <=> list.get(0)`
    println(list.component2())  // 等价于`list[1]  <=> list.get(1)`
    println(list.component3())  // 等价于`list[2]  <=> list.get(2)`
    println(list.component4())  // 等价于`list[3]  <=> list.get(3)`
    println(list.component5())  // 等价于`list[4]  <=> list.get(4)`

输出结果为：

------   contains -------
    false
      ------   elementAt -------
    Java
    10
    null
      ------   get -------
    Java
    10
    null
      ------   first -------
    kotlin
    Android
    kotlin
    Android
      ------   last -------
    IOS
    Android
    IOS
    Android
      ------   indexOf -------
    1
    1
    1
      ------   single -------
    list
    list
    list
    list
      ------   forEach -------
    kotlin
    Android
    Java
    PHP
    Python
    IOS
    index : 0 	 value = kotlin
    index : 1 	 value = Android
    index : 2 	 value = Java
    index : 3 	 value = PHP
    index : 4 	 value = Python
    index : 5 	 value = IOS
      ------   componentX -------
    kotlin
    Android
    Java
    PHP
    Python

### 2.2、顺序操作符 ###

顺序操作符包括：

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

其中从源码的角度说：

1.  `sorted()`函数的核心是`sort()`函数。但这个`sort()`函数我不能直接调用罢了。
2.  `reversed()`函数调用的是`Java`中的`reversed()`函数。
3.  其余的`3`个函数实现的核心为`sortWith()`函数。故而我们也可以用`sortWith()`来实现其他的排序方式

例：

val list1 = listOf(-1,-3,1,3,5,6,7,2,4,10,9,8)
    
    // 反序
    println(list1.reversed())
    
    // 升序
    println(list1.sorted())
    
    // 根据条件升序，即把不满足条件的放在前面，满足条件的放在后面
    println(list1.sortedBy { it % 2 == 0})
    
    // 降序
    println(list1.sortedDescending())
    
    // 根据条件降序，和`sortedBy{}`相反
    println(list1.sortedByDescending { it % 2 == 0 })

输出结果为：

[8, 9, 10, 4, 2, 7, 6, 5, 3, 1, -3, -1]
    [-3, -1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    [-1, -3, 1, 3, 5, 7, 9, 6, 2, 4, 10, 8]
    [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, -1, -3]
    [6, 2, 4, 10, 8, -1, -3, 1, 3, 5, 7, 9]

### 2.3、映射操作符 ###

映射操作符包括：

>  *  `map{...}` : 把每个元素按照特定的方法进行转换，组成一个新的集合。
>  *  `mapNotNull{...}` : 同`map{}`函数的作用相同，只是过滤掉转换之后为`null`的元素
>  *  `mapIndexed{index,result}` : 把每个元素按照特定的方法进行转换，只是其可以操作元素的下标(`index`)，组成一个新的集合。
>  *  `mapIndexedNotNull{index,result}` : 同`mapIndexed{}`函数的作用相同，只是过滤掉转换之后为`null`的元素
>  *  `flatMap{...}` : 根据条件合并两个集合，组成一个新的集合。
>  *  `groupBy{...}` : 分组。即根据条件把集合拆分为为一个`Map<K,List<T>>`类型的集合。具体看实例

例：

val list1 = listOf("kotlin","Android","Java","PHP","JavaScript")
    
    println(list1.map { "str-".plus(it) })
    
    println(list1.mapNotNull { "str-".plus(it) })
    
    println(list1.mapIndexed { index, str ->
        index.toString().plus("-").plus(str)
    })
    
    println(list1.mapIndexedNotNull { index, str ->
        index.toString().plus("-").plus(str)
    })
    
    println( list1.flatMap { listOf(it,"new-".plus(it)) })
    
    println(list1.groupBy { if (it.startsWith("Java")) "big" else "latter" })

输出结果为：

[str-kotlin, str-Android, str-Java, str-PHP, str-JavaScript]
    [str-kotlin, str-Android, str-Java, str-PHP, str-JavaScript]
    [0-kotlin, 1-Android, 2-Java, 3-PHP, 4-JavaScript]
    [0-kotlin, 1-Android, 2-Java, 3-PHP, 4-JavaScript]
    [kotlin, new-kotlin, Android, new-Android, Java, new-Java, PHP, new-PHP, JavaScript, new-JavaScript]
    {latter=[kotlin, Android, PHP], big=[Java, JavaScript]}

### 2.4、过滤操作符 ###

过滤操作符包括：

>  *  `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` : 过滤掉所有不满足执行下标的元素。

例：

val list1 = listOf(-1,-3,1,3,5,6,7,2,4,10,9,8)
    val list2 = listOf(1,3,4,5,null,6,null,10)
    val list3 = listOf(1,1,5,2,2,6,3,3,7,4,4,8)
    
    println("  ------   filter -------")
    println(list1.filter { it > 1  })
    println(list1.filterIndexed { index, result ->
        index < 5 && result > 3
    })
    println(list1.filterNot { it > 1 })
    println(list2.filterNotNull())
    
    println("  ------   take -------")
    println(list1.take(5))
    println(list1.takeWhile { it < 5 })
    println(list1.takeLast(5))
    println(list1.takeLastWhile { it > 5 })
    
    println("  ------   drop -------")
    println(list1.drop(5))
    println(list1.dropWhile { it < 5 })
    println(list1.dropLast(5))
    println(list1.dropLastWhile { it > 5 })
    
    println("  ------   distinct -------")
    println(list3.distinct())
    println(list3.distinctBy { it + 2 })
    
    println("  ------   slice -------")
    println(list1.slice(listOf(1,3,5,7)))
    println(list1.slice(IntRange(1,5)))

输出结果为：

------   filter -------
    [3, 5, 6, 7, 2, 4, 10, 9, 8]
    [5]
    [-1, -3, 1]
    [1, 3, 4, 5, 6, 10]
      ------   take -------
    [-1, -3, 1, 3, 5]
    [-1, -3, 1, 3]
    [2, 4, 10, 9, 8]
    [10, 9, 8]
      ------   drop -------
    [6, 7, 2, 4, 10, 9, 8]
    [5, 6, 7, 2, 4, 10, 9, 8]
    [-1, -3, 1, 3, 5, 6, 7]
    [-1, -3, 1, 3, 5, 6, 7, 2, 4]
      ------   distinct -------
    [1, 5, 2, 6, 3, 7, 4, 8]
    [1, 5, 2, 6, 3, 7, 4, 8]
      ------   slice -------
    [-3, 3, 6, 2]
    [-3, 1, 3, 5, 6]

### 2.5、生产操作符 ###

生产操作符包括：

>  *  `plus()` : 合并两个集合中的元素，组成一个新的集合。也可以使用符号`+`
>  *  `zip` : 由两个集合按照相同的下标组成一个新集合。该新集合的类型是：`List<Pair>`
>  *  `unzip` : 和`zip`的作用相反。把一个类型为`List<Pair>`的集合拆分为两个集合。看下面的例子
>  *  `partition` : 判断元素是否满足条件把集合拆分为有两个`Pair`组成的新集合。

例：

val list1 = listOf(1,2,3,4)
    val list2 = listOf("kotlin","Android","Java","PHP","JavaScript")
    
    // plus() 和 `+`一样
    println(list1.plus(list2))
    println(list1 + list2)
    
    // zip
    println(list1.zip(list2))
    println(list1.zip(list2){       // 组成的新集合由元素少的原集合决定
        it1,it2-> it1.toString().plus("-").plus(it2)
    })
    
    // unzip
    val newList = listOf(Pair(1,"Kotlin"),Pair(2,"Android"),Pair(3,"Java"),Pair(4,"PHP"))
    println(newList.unzip())
    
    // partition
    println(list2.partition { it.startsWith("Ja") })

输出结果为：

[1, 2, 3, 4, kotlin, Android, Java, PHP, JavaScript]
    [1, 2, 3, 4, kotlin, Android, Java, PHP, JavaScript]
    [(1, kotlin), (2, Android), (3, Java), (4, PHP)]
    [1-kotlin, 2-Android, 3-Java, 4-PHP]
    ([1, 2, 3, 4], [Kotlin, Android, Java, PHP])
    ([Java, JavaScript], [kotlin, Android, PHP])

### 2.6、统计操作符 ###

统计操作符包括：

>  *  `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{}`有一个初始值

例：

val list1 = listOf(1,2,3,4,5)
    
    println("  ------   any -------")
    println(list1.any())
    println(list1.any{it > 10})
    
    println("  ------   all -------")
    println(list1.all { it > 2 })
    
    println("  ------   none -------")
    println(list1.none())
    println(list1.none{ it > 2})
    
    println("  ------   max -------")
    println(list1.max())
    println(list1.maxBy { it + 2 })
    
    println("  ------   min -------")
    println(list1.min())        // 返回集合中最小的元素
    println(list1.minBy { it + 2 })
    
    println("  ------   sum -------")
    println(list1.sum())
    println(list1.sumBy { it + 2 })
    println(list1.sumByDouble { it.toDouble() })
    
    println(" ------  average -----")
    println(list1.average())
    
    println("  ------   reduce  -------")
    println(list1.reduce { result, next -> result  + next})
    println(list1.reduceIndexed { index, result, next ->
        index + result + next
    })
    println(list1.reduceRight { result, next -> result  + next })
    println(list1.reduceRightIndexed {index, result, next ->
        index + result + next
    })
    
    println("  ------   fold  -------")
    println(list1.fold(3){result, next -> result  + next})
    println(list1.foldIndexed(3){index,result, next ->
        index + result  + next
    })
    println(list1.foldRight(3){result, next -> result  + next})
    println(list1.foldRightIndexed(3){index,result, next ->
        index + result  + next
    })

输出结果为：

------   any -------
    true
    false
      ------   all -------
    false
      ------   none -------
    false
    false
      ------   max -------
    5
    5
      ------   min -------
    1
    1
      ------   sum -------
    15
    25
    15.0
     ------  average -----
    3.0
      ------   reduce  -------
    15
    25
    15
    21
      ------   fold  -------
    18
    28
    18
    28

## 总结 ##

这篇文章篇幅很长，同时内容也很多。对于操作符讲解的不是很全，主要是介绍常用的操作符。并且对他们的含义即实现进行讲解。但是我相信您学习完上面的内容，对于集合的操作应该是得心印手了。同时了解了这些操作符是怎么实现的。

关于`Kotlin`中对于集合的操作符，我推荐几篇别人的文章：  
[Kotlin系列之常用操作符][Kotlin]  
[Kotlin入门第二课：集合操作][Kotlin 1]  
[Kotlin集合与它的操作符们][Kotlin 2]  
上面几篇文章对于`Kotlin`的全部操作符的介绍与使用讲解的很全面。并且都有例子去实现。

作者：Jetictors  
链接：https://juejin.im/post/5b1f7699f265da6e155d5965  
来源：掘金  
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

[1]: https://user-gold-cdn.xitu.io/2018/6/8/163db7ed370fae80?imageView2/0/w/1280/h/960/format/webp/ignore-error/1
[Kotlin]: https://link.juejin.im?target=https%3A%2F%2Fblog.csdn.net%2Ffine1938768839%2Farticle%2Fdetails%2F73550989
[Kotlin 1]: https://link.juejin.im?target=https%3A%2F%2Fwww.cnblogs.com%2Ftgyf%2Fp%2F6892551.html%3Futm_source%3Ditdadao%26utm_medium%3Dreferral
[Kotlin 2]: https://link.juejin.im?target=https%3A%2F%2Fwww.2cto.com%2Fkf%2F201611%2F567100.html