Kotlin 集合函数锦集，2021程序员进阶宝典

     postfix = "的排名",
    limit = nameCollection.size,
    truncated = "等 "
)
println(message)
//在古代，根据人口数量和宗族的影响力，有刘一 陈二 张三 李四 王五 赵六 孙七 周八 吴九 郑十的排名

}

#### reduce函数将集合转换为单个结果

如果希望将给定集合转换为单个结果，则可以使用reduce函数。例如，你可以计算列表中所有元素的和:

//将集合转换为单个结果
fun transformCollectionResult(){
val numList = listOf(1, 2, 3, 4, 5)
val result = numList.reduce { result, item ->
result + item
}
val mathResult = numList.reduce { mathResult, item ->
mathResult * item
}
println(result) // 15（1 + 2 + 3 + 4 + 5）
println(mathResult) // 120（1 * 2 * 3 * 4 * 5）
}

#### all 判断是否所有的元素都满足特定的条件

如果您有一个数组或数据元素列表，并且您想知道是否所有元素都满足特定的条件，那么您可以在Kotlin中使用all。

//判断是否所有的元素都满足特定的条件
fun isStaisFyingFromElements(){
data class User(val id: Int, val name: String, val isBasketballLover: Boolean, val isFootballLover: Boolean)

val user1 = User(id = 1, name = "张三", isBasketballLover = true, isFootballLover = true)
val user2 = User(id = 2, name = "李四", isBasketballLover = true, isFootballLover = true)
val user3 = User(id = 3, name = "王五", isBasketballLover = true, isFootballLover = false)
val user4 = User(id = 4, name = "赵六", isBasketballLover = true, isFootballLover = false)

val users = arrayOf(user1, user2, user3, user4)

val allLoveCricket = users.all { it.isBasketballLover }
println(allLoveCricket) // true

val allLoveFootball = users.all { it.isFootballLover }
println(allLoveFootball) // false

}

#### find & single函数 根据特定条件找到特定元素

在Kotlin中使用**find**和**single**，可以从满足特定条件的元素列表中找到特定元素。例如，在学生列表中，可以找到学号为3的学生。

注意：

find返回第一个匹配给定条件的元素，如果没有找到匹配的元素，则返回null。

而single返回匹配给定条件的单个元素，如果列表中有多个匹配元素或没有匹配元素，则抛出异常。

//根据特定条件找到特定元素
fun findByCondition(){
    data class User(val id: Int, val name: String)

    val users = arrayOf(
        User(1, "张三"),
        User(2, "李四"),
        User(3, "王五"),
        User(4, "赵六")
    )

    val userWithId3 = users.single { it.id == 3 }
    println(userWithId3) // User(id=3, name=王五)

    val userWithId1 = users.find { it.id == 1 }
    println(userWithId1) // User(id=1, name=张三)
} 
```

#### chunked函数将列表分解为多个子列表

在很多情况下，你有一个大列表，你想把它分成更小的部分，然后在这些子列表上执行一些操作。这个时候可以使用chunked函数。

```
//将列表分解为多个较小大小的子列表
fun breakListMultiple(){
    val numList = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    val chunkedLists = numList.chunked(3)
    println(chunkedLists) // [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]
} 
```

#### 复制数组相关函数

你可以通过使用各种函数来复制现有的数组，例如:

*   copyInto

copyInto可以把一个数组的元素替换成另一个数组，或者，如果目标数组由于大小限制或索引越界而不能保存原始数组的元素，则会出现异常。

```
//复制数组
fun copyIntoArray(){
    val arrayOne = arrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    val arrayTwo = arrayOf(11, 12, 13, 14, 15, 16, 17, 18, 19, 20)
    //将数组arrayOne中从索引0开始（即第1个元素）取出四个元素（即前四个元素）替换数组arrayTwo从索引2开始（即第三个元素）之后的4个元素
    arrayOne.copyInto(destination = arrayTwo, destinationOffset = 2, startIndex = 0, endIndex = 4)
    arrayTwo.forEach {print("$it ")} // 11 12 1 2 3 4 17 18 19 20
} 
```

*   copyOfRange(fromIndex, toIndex)

返回一个新数组，该数组是原数组指定范围的副本。

```
fun copyOfRangeArray(){
    val arrayRange = arrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    val copyOfRange = arrayRange.copyOfRange(0, 6)
    copyOfRange.forEach { print("$it ") }//1 2 3 4 5 6
} 
```

*   copyOf() or copyOf(newSize)

回一个新数组，它是原数组的副本，大小调整为给定的newSize，或者如果newSize未被指定，则整个数组将被复制。

```
fun copyOfArray(){
    val arrayData = arrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    val copyOf = arrayData.copyOf()//1 2 3 4 5 6 7 8 9 10
    copyOf.forEach { print("$it ") }
    println()
    val copyOfNewSize = arrayData.copyOf(7)//1 2 3 4 5 6 7
    copyOfNewSize.forEach { print("$it ") }
} 
```

#### 更改集合类型

根据情况，您可以更改集合的类型。在这里，您可以通过创建一个新集合或引用旧集合来将一个集合的类型更改为另一个集合。例如

*   toIntArray, toBooleanArray, toLongArray, toShortArray, toByteArray, toDoubleArray, toList, toMap, toSet, toPair

等可用于将一个集合的类型更改为另一个集合的类型。

```
//将集合类型更改为int类型
fun changeArrayType(){
    var uIntArray = UIntArray(5) { 2U }
    var intArray = uIntArray.toIntArray()
    intArray[0] = 0
    print(uIntArray.toList()) // [1, 1, 1, 1, 1]
    print(intArray.toList()) // [0, 1, 1, 1, 1]
} 
```

如上，我们通过toIntArray()创建一个新集合，新集合中的更改不会更改旧集合。但是如果你想要改动新集合时，旧集合也同时跟着修改。可以使用as而不是to。例如:

*   asIntArray, asLongArray, asShortArray, asByteArray, asList

```
fun asArrayType(){
    var uIntArray = UIntArray(5) { 1U }
    var intArray = uIntArray.asIntArray()
    intArray[0] = 0
    print(uIntArray.toList()) // [0, 1, 1, 1, 1]
    print(intArray.toList()) // [0, 1, 1, 1, 1]
} 
```

#### associateBy使用某个键（key）关联数据

如果您有一个数据列表，并且希望在数据元素中的某个键(key)关联数据，那么可以使用associateBy。

```
//使用某个键关联数据
fun keyWithData(){
    data class Contact(val name: String, val phoneNumber: String)

    val contactList = listOf(
        Contact("张三", "+86130xxxx1111"),
        Contact("李四", "+86130xxxx2222"),
        Contact("王五", "+86130xxxx3333"),
        Contact("赵六", "+86130xxxx4444")
    )

    //key是phoneNumber，value是Contact。
    val phoneNumberToContactMap = contactList.associateBy { it.phoneNumber }
    println(phoneNumberToContactMap)
    /*
    {
        +86130xxxx1111=Contact(name=张三, phoneNumber=+86130xxxx1111),
        +86130xxxx2222=Contact(name=李四, phoneNumber=+86130xxxx2222),
        +86130xxxx3333=Contact(name=王五, phoneNumber=+86130xxxx3333),
        +86130xxxx4444=Contact(name=赵六, phoneNumber=+86130xxxx4444)
    }
    */

    //key是phoneNumber，value是name。
    val phoneNumberToContactNameMap = contactList.associateBy({it.phoneNumber}, {it.name})
    println(phoneNumberToContactNameMap)
    /*
    {
        +86130xxxx1111=张三,
        +86130xxxx2222=李四,
        +86130xxxx3333=王五,
        +86130xxxx4444=赵六
    }
    */
} 
```

#### distinct函数获取集合中唯一元素的列表

```
//在集合中找到不同的元素
fun findDistinctItem(){
    val list = listOf(1, 2, 2, 3, 3, 3, 4, 4, 4, 4)
    println(list.distinct()) // [1, 2, 3, 4]
} 
```

#### union函数集合合集

使用union函数获取两个集合的唯一元素。两个集合的元素顺序将保持不变，但第二个集合的元素将添加到第一个集合的元素之后。

```
fun unitonCollections(){
    val listOne = listOf(2, 3, 3, 4, 5, 6)
    val listTwo = listOf(1,2, 2, 4, 5, 6, 7, 8)
    println(listOne.union(listTwo)) // [2, 3, 4, 5, 6, 1, 7, 8]
} 
```

#### intersect函数集合交集

要获取两个集合中的公共元素，可以使用intersect函数，该函数返回包含两个集合的公共元素的集合。

```
fun intersectCollections(){
    val listOne = listOf(2, 3, 3, 4, 5, 6)
    val listTwo = listOf(1,2, 2, 4, 5, 6, 7, 8)
    println(listOne.intersect(listTwo)) // [2, 4, 5, 6]
} 
```

#### retainAll、removeAll保留与删除指定元素

如果在集合中，您希望只保留指定的元素，则可以使用retainAll函数。因为这个函数会修改列表，所以要确保列表或数组是可变的。

如果从集合中删除了任何元素，retainAll将返回true，否则将返回false。

```
//只保留指定的元素
fun retainAllTest(){
    val listOne = mutableListOf(1, 2, 3, 3, 3, 4, 5, 6, 8, 9)//元数据源
    val listTwo = listOf(1, 3, 4, 5, 6, 8)//保留指定元素
    println(listOne.retainAll(listTwo)) // true
    println(listOne) // [1, 3, 3, 3, 4, 5, 6, 8]
} 
```

类似地，您可以使用removeAll来删除一个集合中存在于另一个集合中的所有元素。

```
//删除指定的元素
fun removeAllTest(){
    val listOne = mutableListOf(1, 2, 3, 3, 3, 4, 5, 6, 8, 9)//元数据源
    val listTwo = listOf(1, 3, 4, 5, 6, 8)//删除指定元素
    println(listOne.removeAll(listTwo)) // true
    println(listOne) // [2, 9]
} 
```

#### filter根据某些条件筛选集合

```
fun filterCollection(){
    //可以使用筛选器根据特定条件筛选集合。这将返回一个包含满足给定条件的元素的列表。
    val list = listOf(1, 2, 3, 4, 5, 6, 7, 8)
    val filteredList = list.filter { it % 2 == 0 }
    println(filteredList) // [2, 4, 6, 8]

    //如果想在某个集合中存储过滤过的元素，那么你可以使用filterIndexedTo:
    val filterIndexedToList = mutableListOf<Int>()
    list.filterIndexedTo(filterIndexedToList) { index, i -> list[index] % 2 == 0 }
    println(filterIndexedToList) // [2, 4, 6, 8]

    //如果想在集合中找到指定类型的实例元素可以使用filterIsInstance。
    val mixedList = listOf(1, 2, 3, "one", "two", 4, "three", "four", 5, 6, "five", 7)
    val strList = mixedList.filterIsInstance<String>()
    val intList = mixedList.filterIsInstance<Int>()
    println(strList) // [one, two, three, four, five]
    println(intList) // [1, 2, 3, 4, 5, 6, 7]
} 
```

#### zip集合函数

```
fun zipCollections(){
    val listOne = listOf(1,2,3,4,5)
    val listTwo = listOf("a","b","c","d","e","f")
    //Zip返回一对列表。pair的第一个元素将从第一个集合中获取，pair的第二个元素将从第二个集合中获取。返回列表的大小将等于最短集合的大小。
    println(listOne zip listTwo)//[(1, a), (2, b), (3, c), (4, d), (5, e)]

    //zipWithNext返回对列表。对中的元素将是集合中相邻的元素。
    print(listOne.zipWithNext()) // [(1, 2), (2, 3), (3, 4), (4, 5)]
} 
```

#### unzip集合函数

Unzip返回一对列表。第一个列表由每对中的第一个元素组成，第二个列表由每对中的第二个元素组成。

```
fun unzipCollections(){
    val list = listOf("张三" to 8, "李四" to 10, "王五" to 4, "赵六" to 2)
    val (players, footballSkills) = list.unzip()
    println(players) // [张三, 李四, 王五, 赵六]
    print(footballSkills) // [8, 10, 4, 2]
}