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

Posted 2021-07-14 码农 小生

自从Kotlin官宣为android开发首选语言后，大家也都正计划很快转向Kotlin或者已经完全转向Kotlin，接下来我们直奔主题了。

我们在Android应用程序中研发过程中，对于 lists, maps, sets等集合的处理会耗费很多精力，其实有很多Kotlin集合函数，可以让我们事半功倍。

接下来，我们将了解许多Kotlin集合函数。你可以作为Kotlin集合函数的备忘录收藏起来。

过滤数组重复的字符串

有很多方法可以从数组中删除重复的字符串:

//过滤数组重复的字符串
fun removeDuplicateStrings(){
    //保持原始顺序
    val devsDistinct = arrayOf("张三", "李四", "王五", "赵六", "赵六", "孙七")
    println(devsDistinct.distinct()) // [张三, 李四, 王五, 赵六, 孙七]

    //保持原始顺序
    val devsToSet = arrayOf("张三", "李四", "王五", "赵六", "赵六", "孙七")
    println(devsToSet.toSet()) // [张三, 李四, 王五, 赵六, 孙七]

    //保持原始顺序
    val devsToMutableSet = arrayOf("张三", "李四", "王五", "赵六", "赵六", "孙七")
    println(devsToMutableSet.toMutableSet()) // [张三, 李四, 王五, 赵六, 孙七]

    //不保持原始顺序，无序返回
    val devsToHashSet = arrayOf("张三", "李四", "王五", "赵六", "赵六", "孙七")
    println(devsToHashSet.toHashSet()) // [李四, 孙七, 张三, 王五, 赵六]
}

joinToString函数将数组或列表转换为字符串

可以使用joinToString将数组或列表转换为字符串。例如，如果您有一个姓氏列表(张三、李四、王五)，那么您可以将该列表转换为一个字符串，例如“在古代，根据人口数量和宗族的影响力，有刘一 陈二 张三 李四 王五 赵六 孙七 周八 吴九 郑十的排名” 其中刘一 陈二 张三 李四 王五 赵六 孙七 周八 吴九 郑十是你的列表。

//将数组或列表转换为字符串
fun convertListToString(){
    val nameCollection = listOf(
        "刘一", "陈二",
        "张三", "李四",
        "王五", "赵六",
        "孙七", "周八",
        "吴九", "郑十"
    )

    val message = nameCollection.joinToString(
        separator = " ",
        prefix = "在古代，根据人口数量和宗族的影响力，有",
        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]
}

partition函数根据某些条件将数组分成两部分

如果您想根据某些条件(如isFootballFan)将数据分成两部分，那么可以使用分区。

//根据某些条件将数组分成两部分
fun splitArray(){
    data class User(val id: Int, val name: String, val isFootballLover: Boolean)

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

    val (footballLovers, nonFootballLovers) = users.partition { it.isFootballLover }
    println(footballLovers)//[User(id=1, name=张三, isFootballLover=true), User(id=2, name=李四, isFootballLover=true)]
    print(nonFootballLovers)//[User(id=3, name=王五, isFootballLover=false), User(id=4, name=赵六, isFootballLover=false)]
}

reversed函数反转倒序一个列表

您可以通过使用reversed和asReversed函数逆转Kotlin中的列表。

fun reverseList(){
    val list = listOf(1, 2, 3, 4, 5)
    println(list.reversed()) // [5, 4, 3, 2, 1]
    print(list.asReversed()) // [5, 4, 3, 2, 1]
}

reversed和asReversed两者都给出相同的输出，但这些函数是不同的。

reverse()函数可以应用于Array、List和MutableList。它生成一个与原始列表相反的新列表。

但是asReversed()函数可以应用于List和MutableList。它不会生成新列表，因为在反转之后，新元素仍然指向旧元素。所以其中一个的变化会导致另一个的变化。

类似地，还可以使用其他函数来反转元素，如reversedArray()、reverse()。

groupBy根据某些条件对集合的元素进行分组

可以使用groupBy()根据某些条件对集合的元素进行分组。例如，下面的代码将根据被4除后的余数对列表中的元素进行分组，即4组(当余数= 0、1、2和3时)

//根据某些条件对集合的元素进行分组
fun groupList(){
    val list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    print(list.groupBy { it % 4 })
    /*
    {
        1=[1, 5, 9],
        2=[2, 6, 10],
        3=[3, 7],
        0=[4, 8]
    }
    */
}

sorted函数集合排序

可以使用sorted()函数对集合中的元素进行排序。这将返回一个已排序的列表。

//集合的排序元素
fun sortLsit(){
    val list = listOf(10, 4, 1, 3, 7, 2, 6)
    print(list.sorted()) // [1, 2, 3, 4, 6, 7, 10]
}

类似地，还可以使用其他函数根据某些条件对集合进行排序。其中一些函数是

• sortedArray sortedArrayWith sortedBy sortedByDescending sortedArraydescending sortedWith

如上是在Kotlin中处理集合时可以使用的集合函数。