Kotlin集合操作整理

Posted 2022-12-06 且听真言

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Kotlin集合操作整理相关的知识，希望对你有一定的参考价值。

一、转换类

1.1转换为数组

集合类提供了toIntArray()、toDoubleArray()、toFloatArray()、toBetArray()等函数，将集合转换成相应的数组。

例：toIntArray()方法

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

例子：

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])

class java.util.Arrays$ArrayList
class [I
2

1.2转换为集合

集合类提供了toList()、toMutableList()、toSet()、toMutableSet()、toHashSet()、toMap()等高阶函数将一个集合或者数组转换成相应等集合类型。

例：toList()方法

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()

例子：

// 数组转集合
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

二、操作类

2.1元素操作符

contains(元素) : 检查集合中是否包含指定的元素，若存在则返回true，反之返回false

fun testContains() 
    val list = listOf<Int>(1, 2, 3, 4)
    println(list.contains(1))

true

elementAt(index) : 获取对应下标的元素。若下标越界，会抛出IndexOutOfBoundsException（下标越界）异常，同get(index)一样

fun testElementAt()
    val list = listOf<Int>(1, 2, 3, 4)
    println(list.elementAt(2))

3

elementAtOrElse(index,...) : 获取对应下标的元素。若下标越界，返回默认值，此默认值就是你传入的下标的运算值

/**
 * Returns an element at the given [index] or the result of calling the [defaultValue] function if the [index] is out of bounds of this list.
 * 
 * @sample samples.collections.Collections.Elements.elementAtOrElse
 */
@kotlin.internal.InlineOnly
public inline fun <T> List<T>.elementAtOrElse(index: Int, defaultValue: (Int) -> T): T 
    return if (index >= 0 && index <= lastIndex) get(index) else defaultValue(index)

elementAtOrNull(index) : 获取对应下标的元素。若下标越界，返回null
first() : 获取第一个元素，若集合为空集合，这会抛出NoSuchElementException异常

fun testListFirst() 
    val list = listOf<Int>(1, 2, 3, 4)
    val first = list.first()
    println(first)


1

first : 获取指定元素的第一个元素。若不满足条件，则抛出NoSuchElementException异常

/**
 * Returns the first element matching the given [predicate].
 * @throws [NoSuchElementException] if no such element is found.
 */
public inline fun <T> Iterable<T>.first(predicate: (T) -> Boolean): T 
    for (element in this) if (predicate(element)) return element
    throw NoSuchElementException("Collection contains no element matching the predicate.")

fun testListFirst2() 
    val list = listOf<Int>(1, 2, 3, 4)

    val first = list.first  isTwo(it) 
    println(first)


fun isTwo(value: Int):Boolean 
    return value == 2


1

firstOrNull() : 获取第一个元素，若集合为空集合，返回null
firstOrNull : 获取指定元素的第一个元素。若不满足条件，返回null
getOrElse(index,...) : 同elementAtOrElse一样

/**
 * Returns an element at the given [index] or the result of calling the [defaultValue] function if the [index] is out of bounds of this list.
 */
@kotlin.internal.InlineOnly
public inline fun <T> List<T>.getOrElse(index: Int, defaultValue: (Int) -> T): T 
    return if (index >= 0 && index <= lastIndex) get(index) else defaultValue(index)

fun testGetOrElse() 
    val listOf = listOf<Int>(1, 2, 3, 4)
    val orElse = listOf.getOrElse(8, ::initDefaultValue)
    println(orElse)


fun initDefaultValue(value: Int): Int 
    return 888


888

getOrNull(index) : 同elementAtOrNull一样

fun testgetOrNull() 
    val listOf = listOf<Int>(1, 2, 3, 4)
    val index2Value = listOf.getOrNull(2)
    println(index2Value)

    val index9Value = listOf.getOrNull(9)
    println(index9Value)


3
null

last() : 同first()相反
last : 同first相反

fun testlistLast() 
    val list = listOf<Int>(1, 2, 3, 4)
    val last = list.last()
    println(last)

    val last1 = list.last 
        it < 2
    

    println(last1)


4
1

lastOrNull : 同firstOrNull()相反
lastOrNull() : 同firstOrNull相反

indexOf(元素) : 返回指定元素的下标，若不存在，则返回-1

fun testIndexOf() 
    val listOf = listOf<Int>(1, 2, 3, 4)
    val indexOf_value_1 = listOf.indexOf(1)
    val indexOf_value_0 = listOf.indexOf(0)
    println("$indexOf_value_0;$indexOf_value_1")


-1;0

indexOfFirst... : 返回第一个满足条件元素的下标，若不存在，则返回-1

fun testIndexOfFirst() 
    val listOf = listOf<Int>(1, 2, 3, 4)
    val indexOfFirst = listOf.indexOfFirst 
        it > 3
    

    println(indexOfFirst)

    val indexOfFirst1 = listOf.indexOfFirst 
        it > 10
    

    println(indexOfFirst1)


3
-1

indexOfLast... : 返回最后一个满足条件元素的下标，若不存在，则返回-1

fun testIndexOfLast() 
    val list = listOf<Int>(1, 2, 3, 4)
    val indexOfLast = list.indexOfLast 
        it > 2
    
    println(indexOfLast)

    val indexOfLast1 = list.indexOfLast  it > 9 
    println(indexOfLast1)


3
-1

single() : 若集合的长度等于0,则抛出NoSuchElementException异常，若等于1，则返回第一个元素。反之，则抛出IllegalArgumentException异常

fun testSingle() 
    val listOf = listOf<Int>(4)
    val single = listOf.single()
    println(single)


4

single : 找到集合中满足条件的元素，若元素满足条件，则返回该元素。否则会根据不同的条件，抛出异常。这个方法慎用

fun testSingleTwo() 
    val listOf = listOf<Int>(5)
    val single = listOf.single  it > 2 
    println(single)


5

singleOrNull() : 若集合的长度等于1,则返回第一个元素。否则，返回null
singleOrNull : 找到集合中满足条件的元素，若元素满足条件，则返回该元素。否则返回null
forEach... : 遍历元素。一般用作元素的打印
forEachIndexedindex,value : 遍历元素，可获得集合中元素的下标。一般用作元素以及下标的打印

fun testforEachIndexedTwo() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6)
    listOf.forEachIndexed index, value ->
        println("index:$index;value:$value")
    


index:0;value:1
index:1;value:2
index:2;value:3
index:3;value:4
index:4;value:5
index:5;value:6

componentX() ：这个函数在前面的章节中提过多次了。用于获取元素。其中的X只能代表1..5。

fun testComponentX() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6)
    val component1 = listOf.component1()
    val component2 = listOf.component2()
    println("component1=$component1;component2=$component2")


component1=1;component2=2

2.2顺序操作符

reversed() : 反序。即和初始化的顺序反过来。

fun testReversed() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6)
    println(listOf.reversed())


[6, 5, 4, 3, 2, 1]

sorted() : 自然升序。

fun testSorted() 
    val listOf = listOf<Int>(3, 2, 3, 5, 4, 1)
    println(listOf.sorted())

[1, 2, 3, 3, 4, 5]

sortedBy : 根据条件升序，即把不满足条件的放在前面，满足条件的放在后面

fun testSortedBy() 
    val listOf = listOf<Int>(3, 2, 3, 5, 4, 1)
    val sortedBy = listOf.sortedBy 
        it > 2
    
    println(sortedBy)

[2, 1, 3, 3, 5, 4]

sortedDescending() : 自然降序。

fun testsortedDescending() 
    val listOf = listOf<Int>(3, 2, 3, 5, 4, 1)
    println(listOf.sortedDescending())

[5, 4, 3, 3, 2, 1]

sortedByDescending : 根据条件降序。

fun testsortedByDescending() 
    val listOf = listOf<Int>(3, 2, 3, 5, 4, 1)
    val sortedByDescending = listOf.sortedByDescending  it > 3 
    println(sortedByDescending)

[5, 4, 3, 2, 3, 1]

2.3映射操作符

map... : 把每个元素按照特定的方法进行转换，组成一个新的集合。

fun testMap() 
    val listOf = listOf<Int>(3, 2, 3, 5, 4, 1)
    val map = listOf.map  it * 2 
    println(map)

[6, 4, 6, 10, 8, 2]

mapNotNull... : 同map函数的作用相同，只是过滤掉转换之后为null的元素

fun mapNotNull() 
    val listOf = listOf<Int?>(3, 2, 3, 5, 4, null)
    val map = listOf.mapNotNull 
        it?.let 
            it * 3
        
    
    println(map)

[9, 6, 9, 15, 12]

mapIndexedindex,result : 把每个元素按照特定的方法进行转换，只是其可以操作元素的下标(index)，组成一个新的集合。

fun testMapIndexed() 
    val listOf = listOf<Int>(3, 2, 3, 5, 4, 1)
    listOf.mapIndexed  index, result ->
       println("$index,$result")
    


0,3
1,2
2,3
3,5
4,4
5,1

fun testMapIndexed() 
    val listOf = listOf<Int>(3, 2, 3, 5, 4, 1)
    val mapIndexed = listOf.mapIndexed  index, result ->
        result * 9
    
    println(mapIndexed)


[27, 18, 27, 45, 36, 9]

fun testMapIndexed() 
    val listOf = listOf<Int>(3, 2, 3, 5, 4, 1)
    val mapIndexed = listOf.mapIndexed  index, result ->
        if (index > 3) 
            result * 9
         else result

    
    println(mapIndexed)


[3, 2, 3, 5, 36, 9]

mapIndexedNotNullindex,result : 同mapIndexed函数的作用相同，只是过滤掉转换之后为null的元素

fun mapIndexedNotNull() 
    val listOf = listOf<Int?>(3, 2, 3, 5, 4, null)
    val mapIndexed = listOf.mapIndexedNotNull()  index, result ->
        if (index > 3) 
            result?.let 
                result * 9
            
         else result

    
    println(mapIndexed)


[3, 2, 3, 5, 36]

flatMap... : 根据条件合并两个集合，组成一个新的集合。flatMap 遍历所有的元素，为每一个创建一个集合，最后把所有的集合放在一个集合中。

/**
 * Returns a single list of all elements yielded from results of [transform] function being invoked on each element of original collection.
 * 
 * @sample samples.collections.Collections.Transformations.flatMap
 */
public inline fun <T, R> Iterable<T>.flatMap(transform: (T) -> Iterable<R>): List<R> 
    return flatMapTo(ArrayList<R>(), transform)


/**
 * Appends all elements yielded from results of [transform] function being invoked on each element of original collection, to the given [destination].
 */
public inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapTo(destination: C, transform: (T) -> Iterable<R>): C 
    for (element in this) 
        val list = transform(element)
        destination.addAll(list)
    
    return destination

fun testflatMap() 
    val listOf1 = listOf<Int>(3, 2, 3, 5, 4, 1)
    val flatMap = listOf1.flatMap 
        listOf(it +1)
    
    println(flatMap)

[4, 3, 4, 6, 5, 2]

groupBy... : 分组。即根据条件把集合拆分为为一个Map<K,List<T>>类型的集合。

fun testGroupBy() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val groupBy = listOf.groupBy 
        if (it > 4) "big" else "small"
    
    println(groupBy)


small=[1, 2, 3, 4], big=[5, 6, 7]

2.4过滤操作符

filter... : 把不满足条件的元素过滤掉

fun testFilter() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val filter = listOf.filter 
        it > 3
    
    println(filter)


[4, 5, 6, 7]

filterIndexed... : 和filter函数作用类似，只是可以操作集合中元素的下标（index）

fun testFilterIndexed() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val filterIndexed = listOf.filterIndexed  index, result ->
        index < 5 && result > 1
    

    println(filterIndexed)


[2, 3, 4, 5]

filterNot... : 和filter函数的作用相反

fun testFilterNot() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val filterNot = listOf.filterNot 
        it > 4
    

    println(filterNot)

[1, 2, 3, 4]

filterNotNull() : 过滤掉集合中为null的元素。

fun testFilterNotNull() 
    val listOf = listOf<Int?>(1, 2, 3, 4, 5, 6, null)
    val filterNotNull = listOf.filterNotNull()
    println(filterNotNull)

[1, 2, 3, 4, 5, 6]

take(num) : 返回集合中前num个元素组成的集合

fun testTake() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val take = listOf.take(2)
    println(take)

[1, 2]

takeWhile... : 循环遍历集合，从第一个元素开始遍历集合，当第一个出现不满足条件元素的时候，退出遍历。然后把满足条件所有元素组成的集合返回。

fun testTakeWhile() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val takeWhile = listOf.takeWhile 
        it < 6
    
    println(takeWhile)

[1, 2, 3, 4, 5]

takeLast(num) : 返回集合中后num个元素组成的集合

fun testTakeLast() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val take = listOf.takeLast(2)
    println(take)

[6, 7]

takeLastWhile... : 循环遍历集合，从最后一个元素开始遍历集合，当第一个出现不满足条件元素的时候，退出遍历。然后把满足条件所有元素组成的集合返回。

fun testTakeLastWhile() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val takeLastWhile = listOf.takeLastWhile 
        it > 5
    
    println(takeLastWhile)

[6, 7]

drop(num) : 过滤集合中前num个元素

fun testDrop() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val drop = listOf.drop(3)
    println(drop)

[4, 5, 6, 7]

dropWhile... : 相同条件下，和执行takeWhile...函数后得到的结果相反

fun testDropWhile() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val dropWhile = listOf.dropWhile 
        it < 6
    
    println(dropWhile)

[6, 7]

dropLast(num) : 过滤集合中后num个元素

fun testDropLast() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val dropLast = listOf.dropLast(2)
    println(dropLast)

[1, 2, 3, 4, 5]

dropLastWhile... : 相同条件下，和执行takeLastWhile...函数后得到的结果相反

fun testDropLastWhile() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val dropLastWhile = listOf.dropLastWhile 
        it > 5
    
    println(dropLastWhile)

[1, 2, 3, 4, 5]

distinct() : 去除重复元素

fun testDistinct() 
    val listOf = listOf<Int>(1, 1, 3, 4, 5, 5, 7)
    val distinct = listOf.distinct()
    println(distinct)

[1, 3, 4, 5, 7]

distinctBy... : 根据操作元素后的结果去除重复元素

/**
 * Returns a list containing only elements from the given collection
 * having distinct keys returned by the given [selector] function.
 * 
 * Among elements of the given collection with equal keys, only the first one will be present in the resulting list.
 * The elements in the resulting list are in the same order as they were in the source collection.
 * 
 * @sample samples.collections.Collections.Transformations.distinctAndDistinctBy
 */
public inline fun <T, K> Iterable<T>.distinctBy(selector: (T) -> K): List<T> 
    val set = HashSet<K>()
    val list = ArrayList<T>()
    for (e in this) 
        val key = selector(e)
        if (set.add(key))
            list.add(e)
    
    return list

fun testDistinctBy() 
    val listOf = listOf<Int>(1, 1, 3, 4, 5, 5, 7)
    println(listOf.distinctBy  it + 2 )

[1, 3, 4, 5, 7]
其实这个方法是去除了it+2的重复的值，最终保存回到集合中的还是it 本身

slice : 过滤掉所有不满足执行下标的元素。

fun testSlice() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val slice = listOf.slice(2..3)
    println(slice)


[3, 4]


fun testSlice2() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    println(listOf.slice(listOf(1, 3)))


[2, 4]

/**
 * Returns a list containing elements at indices in the specified [indices] range.
 */
public fun <T> List<T>.slice(indices: IntRange): List<T> 
    if (indices.isEmpty()) return listOf()
    return this.subList(indices.start, indices.endInclusive + 1).toList()


/**
 * Returns a list containing elements at specified [indices].
 */
public fun <T> List<T>.slice(indices: Iterable<Int>): List<T> 
    val size = indices.collectionSizeOrDefault(10)
    if (size == 0) return emptyList()
    val list = ArrayList<T>(size)
    for (index in indices) 
        list.add(get(index))
    
    return list

2.5生产操作符

plus() : 合并两个集合中的元素，组成一个新的集合。也可以使用符号+

fun testPlus() 
    val listOf1 = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val listOf2 = listOf<Int>(1, 2, 3, 4, 5, 6, 7)

    val plus = listOf1.plus(listOf2)
    println(plus)


[1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7]

zip : 由两个集合按照相同的下标组成一个新集合。该新集合的类型是：List<Pair>

fun testZip() 
    val listOf1 = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val listOf2 = listOf<Int>(8, 9, 10, 11, 12, 13, 14)
    val zip = listOf1.zip(listOf2)
    println(zip)

    zip.forEach 
        println("""$it.first;$it.second""")
    


[(1, 8), (2, 9), (3, 10), (4, 11), (5, 12), (6, 13), (7, 14)]
1;8
2;9
3;10
4;11
5;12
6;13
7;14

unzip : 和zip的作用相反。把一个类型为List<Pair>的集合拆分为两个集合。看下面的例子

fun testUnZip() 
    val listOf1 = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val listOf2 = listOf<Int>(8, 9, 10, 11, 12, 13, 14)
    val zip = listOf1.zip(listOf2)
    val unzip = zip.unzip()
    println(unzip.first)
    println(unzip.second)


[1, 2, 3, 4, 5, 6, 7]
[8, 9, 10, 11, 12, 13, 14]

partition : 判断元素是否满足条件把集合拆分为有两个Pair组成的新集合。

fun testPartition() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val partition = listOf.partition 
        it > 3
    
    println(partition.first)
    println(partition.second)


[4, 5, 6, 7]
[1, 2, 3]

2.6统计操作符

any() : 判断是不是一个集合，若是，则在判断集合是否为空，若为空则返回false,反之返回true,若不是集合，则返回hasNext

fun testAny() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    println(listOf.any())
    val emptyList = emptyList<Int>()
    println(emptyList.any())


true
false

any... : 判断集合中是否存在满足条件的元素。若存在则返回true,反之返回false

fun testAny2() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val any1 = listOf.any 
        it == 3
    
    println(any1)

    val any2 = listOf.any 
        it == 9
    
    println(any2)


true
false

all... : 判断集合中的所有元素是否都满足条件。若是则返回true,反之则返回false

fun testAll() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val all = listOf.all 
        it > 0
    
    println(all)

    val listOf2 = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val all1 = listOf2.all 
        it > 5
    
    println(all1)

true
false

none() : 和any()函数的作用相反

fun testNOne() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val none = listOf.none()
    println(none)


false

none... : 和all...函数的作用相反

fun testNone2() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val none = listOf.none 
        it > 0
    
    println(none)

    val none1 = listOf.none 
        it > 3
    
    println(none1)

false
false

max() : 获取集合中最大的元素，若为空元素集合，则返回null

fun testMax() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val max = listOf.max()
    println(max)

7

maxBy... : 获取方法处理后返回结果最大值对应那个元素的初始值，如果没有则返回null

fun testMaxBy() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val maxBy = listOf.maxBy 
        it > 5
    
    println(maxBy)


6

@Deprecated("Use maxByOrNull instead.", ReplaceWith("maxByOrNull(selector)"))
@DeprecatedSinceKotlin(warningSince = "1.4")
public inline fun <T, R : Comparable<R>> Iterable<T>.maxBy(selector: (T) -> R): T? 
    return maxByOrNull(selector)


/**
 * Returns the first element yielding the largest value of the given function or `null` if there are no elements.
 * 
 * @sample samples.collections.Collections.Aggregates.maxByOrNull
 */
@SinceKotlin("1.4")
public inline fun <T, R : Comparable<R>> Iterable<T>.maxByOrNull(selector: (T) -> R): T? 
    val iterator = iterator()
    if (!iterator.hasNext()) return null
    var maxElem = iterator.next()
    if (!iterator.hasNext()) return maxElem
    var maxValue = selector(maxElem)
    do 
        val e = iterator.next()
        val v = selector(e)
        if (maxValue < v) 
            maxElem = e
            maxValue = v
        
     while (iterator.hasNext())
    return maxElem

min() : 获取集合中最小的元素，若为空元素集合，则返回null

fun testMin() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val min = listOf.min()
    println(min)

1

minBy... : 获取方法处理后返回结果最小值对应那个元素的初始值，如果没有则返回null

fun testMinBy() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val minBy = listOf.minBy 
        it + 2
    
    println(minBy)

1

sum() : 计算出集合元素累加的结果。

fun testSum() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val sum = listOf.sum()
    println(sum)

28

sumBy... : 根据元素运算操作后的结果，然后根据这个结果计算出累加的值。

fun testSumBy() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val sumBy = listOf.sumBy 
        it + 2
    
    println(sumBy)


42

sumByDouble... : 和sumBy相似，不过sumBy是操作Int类型数据，而sumByDouble操作的是Double类型数据

fun testsumByDouble() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val sumByDouble = listOf.sumByDouble 
        it.toDouble()
    
    println(sumByDouble)

28.0

average() : 获取平均数

/**
 *   获取平均数
 */
fun testAverage() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val average = listOf.average()
    println(average)

4.0

reduce... : 从集合中的第一项到最后一项的累计操作。

fun testReduce() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val reduce = listOf.reduce  result, next ->
        result + next
    
    println(reduce)

28

reduceIndexed... : 和reduce作用相同，只是其可以操作元素的下标(index)

fun testReduceIndexed() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val reduceRightIndexed = listOf.reduceRightIndexed  index, result, next ->
        index + result + next
    
    println(reduceRightIndexed)

43

reduceRight... : 从集合中的最后一项到第一项的累计操作。

fun testReduceRight() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val reduceRight = listOf.reduceRight  result, next ->
        result + next
    
    println(reduceRight)


28

reduceRightIndexed... : 和reduceRight作用相同，只是其可以操作元素的下标(index)

fun reduceRightIndexed() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val reduceRightIndexed = listOf.reduceRightIndexed  index, result, next ->
        index + result + next
    
    println(reduceRightIndexed)

43

fold... : 和reduce类似，但是fold有一个初始值

fun testFoldValue() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val fold = listOf.fold(100)  result, next ->
        result + next
    
    println(fold)

128

foldIndexed... : 和reduceIndexed类似，但是foldIndexed有一个初始值

fun testFoldIndexed() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val foldIndexed = listOf.foldIndexed(100)  index, result, next ->
        println(index)
        index + result + next
    
    println(foldIndexed)

149

foldRight... : 和reduceRight类似，但是foldRight有一个初始值

fun testFoldRight() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val foldRight = listOf.foldRight(100)  result, next ->
        result + next
    
    println(foldRight)

128

foldRightIndexed... : 和reduceRightIndexed类似，但是foldRightIndexed有一个初始值

fun testFoldRightIndexed() 
    val listOf = listOf<Int>(1, 2, 3, 4, 5, 6, 7)
    val foldRightIndexed = listOf.foldRightIndexed(100)  index, result, next ->
        index + result + next
    
    println(foldRightIndexed)

149

以上是关于Kotlin集合操作整理的主要内容，如果未能解决你的问题，请参考以下文章

Kotlin常用Collection集合操作整理

Kotlin集合操作整理

什么？有人整理了Kotlin 集合函数锦集！！

Kotlin 与 Swift 的简单对比，简直是太像了

初识Kotlin之集合

Kotlin集合简介