kotlin 内置函数对数组进行各种操作

遥不可及zzz2023-11-27 22:35

以下是一些常见的用法示例：

  • plus() 函数将两个数组合并成一个数组。plus() 函数是 Kotlin 标准库中的一个扩展函数，可以用于合并两个同类型的数组。

    复制代码 
    fun main() {
    val array1 = arrayOf(1, 2, 3)
    val array2 = arrayOf(4, 5, 6)

    val mergedArray = array1.plus(array2)

    println(mergedArray.contentToString()) // 输出 [1, 2, 3, 4, 5, 6]
}

  • 使用 minus() 函数从数组中移除指定元素，并返回新的数组

Kotlin 复制代码 
val array = arrayOf(1, 2, 3, 4, 5)
val newArray = array.minus(3) // 移除元素 3
println(newArray.contentToString()) // 输出 [1, 2, 4, 5]
  • 使用 slice() 函数获取数组中指定位置的元素，并返回新的数组：
Kotlin 复制代码 
val array = arrayOf(1, 2, 3, 4, 5)
val slicedArray = array.slice(1..3) // 获取索引为 1 到 3 的元素
println(slicedArray.contentToString()) // 输出 [2, 3, 4]
  • 使用 chunked() 函数将数组分成指定大小的块，并返回一个列表：
Kotlin 复制代码 
val array = arrayOf(1, 2, 3, 4, 5)
val chunkedList = array.chunked(2) // 将数组分成大小为 2 的块
println(chunkedList) // 输出 [[1, 2], [3, 4], [5]]
  • 使用 distinct() 函数获取数组中不同的元素，并返回新的数组
Kotlin 复制代码 
val array = arrayOf(1, 2, 2, 3, 3, 4, 5)
val distinctArray = array.distinct() // 获取不同的元素
println(distinctArray.contentToString()) // 输出 [1, 2, 3, 4, 5]

find()：用于在数组中查找符合指定条件的元素，并返回该元素

Kotlin 复制代码 
val numbers = listOf(1, 2, 3, 4, 5)

val result = numbers.find { it % 2 == 0 }

println(result) // 输出：2
  • joinToString()：用于将数组中的元素连接成字符串，并返回该字符串。
Kotlin 复制代码 
fun main() {  
    val array = arrayOf("Hello", "World")  
    val result = array.joinToString()  
    println(result) // 输出 "HelloWorld"  
}
  • map()：用于根据指定规则将数组中的元素进行映射，并返回一个新的数组。
Kotlin 复制代码 
fun String.toUpperCase(): String {  
    return this.toUpperCase()  
}  
  
val strings = listOf("apple", "banana", "cherry")  
  
// 使用自定义的 toUpperCase() 函数将字符串转换为大写  
val upperCaseStrings = strings.map { it.toUpperCase() }  
  
println(upperCaseStrings) // 输出 [APPLE, BANANA, CHERRY]
  • sum()：用于计算数组中所有元素的和。
Kotlin 复制代码 
fun main() {  
    val numbers = listOf(1, 2, 3, 4, 5)  
  
    // 使用 sum() 函数计算所有数字的总和  
    val sum = numbers.sum()  
  
    println("Sum of numbers: $sum") // 输出 "Sum of numbers: 15"  
}
  • first()：返回第一个元素
Kotlin 复制代码 
fun main() {  
    val numbers = listOf(1, 2, 3, 4, 5)  
  
    // 使用 first() 函数获取第一个数字  
    val firstNumber = numbers.first()  
  
    println("First number: $firstNumber") // 输出 "First number: 1"  
}
  • last()：返回最后一个元素
Kotlin 复制代码 
fun main() {  
    val numbers = listOf(1, 2, 3, 4, 5)  
  
    // 使用 last() 函数获取最后一个数字  
    val lastNumber = numbers.last()  
  
    println("Last number: $lastNumber") // 输出 "Last number: 5"  
}
  • firstOrNull()：返回第一个元素，如果数组为空则返回null
  • lastOrNull()：返回最后一个元素，如果数组为空则返回null
  • getOrNull()：根据下标获取元素，如果下标越界则返回null
Kotlin 复制代码 
val map = mapOf("apple" to 1, "banana" to 2, "orange" to 3)  
  
// 获取键为 "apple" 的值，如果不存在则返回 null  
val appleValue = map.getOrNull("apple")  
println("Apple value: $appleValue") // 输出 "Apple value: 1"  
  
// 获取键为 "grape" 的值，如果不存在则返回 null  
val grapeValue = map.getOrNull("grape")  
println("Grape value: $grapeValue") // 输出 "Grape value: null"
  • take()：获取前n个元素
Kotlin 复制代码 
fun main() {  
    val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)  
  
    // 使用 take() 函数获取前三个数字  
    val result = numbers.take(3)  
  
    // 遍历并打印结果  
    for (num in result) {  
        println(num)  
    }  
}
我们使用循环遍历并打印结果。输出将为：

1  
2  
3
  • takeLast()：获取后n个元素
Kotlin 复制代码 
fun main() {  
    val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)  
  
    // 使用 takeLast() 函数获取最后三个数字  
    val result = numbers.takeLast(3)  
  
    // 遍历并打印结果  
    for (num in result) {  
        println(num)  
    }  
}
输出将为：

7  
8  
9
  • drop()：去除前n个元素
Kotlin 复制代码 
 val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

    // 使用 drop() 函数删除前三个数字
    val result = numbers.drop(3)

    // 打印删除元素后的新序列
    println(result) // 输出 [4, 5, 6, 7, 8, 9, 10]
  • dropLast()：去除后n个元素
Kotlin 复制代码 
                                                
var numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 
                                                
// 使用 dropLast() 函数删除最后三个数字并将结果分配回原始列表          
numbers = numbers.dropLast(3)                   
                                                
// 打印修改后的原始列表                                   
println(numbers) // 输出 [1, 2, 3, 4, 5, 6, 7]
  • filter()：根据条件筛选元素
Kotlin 复制代码 
fun main() {  
    val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)  
  
    // 使用 filter() 函数筛选出偶数并打印  
    val evenNumbers = numbers.filter { it % 2 == 0 }  
    println(evenNumbers)  // 输出：[2, 4, 6, 8, 10]  
}
  • map()：对每个元素执行指定操作
Kotlin 复制代码 
fun main() {  
    // 创建一个包含字符串的列表  
    val strings = listOf("apple", "banana", "orange")  
  
    // 使用 map() 函数将字符串转换为它们的长度，并打印结果  
    val lengths = strings.map { it.length }  
    println(lengths)  // 输出：[6, 6, 5]  
}
  • flatMap()：对每个元素执行指定操作，并将结果合并到一个列表中
Kotlin 复制代码 
fun main() {  
    val listOfLists = listOf(listOf(1, 2, 3), listOf(4, 5, 6), listOf(7, 8, 9))  
  
    val flattenedList = listOfLists.flatMap { it }  
  
    println(flattenedList) // 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9]  
}

  • distinct()：去除重复元素

    Kotlin 复制代码 
    fun main() {  
    val numbers = listOf(1, 2, 2, 3, 4, 4, 5)  
  
    val uniqueNumbers = numbers.distinct()  
  
    println(uniqueNumbers) // 输出了 [1, 2, 3, 4, 5]  
}

distinctBy()：根据指定条件去除重复元素

Kotlin 复制代码 
fun main() {  
    val items = listOf("apple", "banana", "cherry", "date", "elderberry")  
  
    val distinctItems = items.distinctBy { it.length }  
  
    println(distinctItems) // 输出了 [apple, banana, cherry, date]  
}
  • contains()：判断数组是否包含指定元素
Kotlin 复制代码 
fun main() {  
    val numbers = listOf(1, 2, 3, 4, 5)  
  
    val containsThree = numbers.contains(3)  
  
    println(containsThree) // 输出：true  
}
  • indexOf()：获取指定元素的下标，如果不存在则返回-1
Kotlin 复制代码 
fun main() {  
    val numbers = listOf(1, 2, 3, 4, 5)  
  
    val index = numbers.indexOf(3)  
  
    println("The index of 3 is: $index") // 输出：The index of 3 is: 2  
}
我们打印出结果，显示数字 3 在列表中的位置。请注意，indexOf() 函数返回的是该元素在列表中的位置，索引从 0 开始。

  • lastIndexOf()：获取指定元素的最后一个下标，如果不存在则返回-1

    Kotlin 复制代码 
    fun main() {  
    val numbers = listOf(1, 2, 3, 4, 5, 3)  
  
    val lastIndex = numbers.lastIndexOf(3)  
  
    println("The last index of 3 is: $lastIndex") // 输出：The last index of 3 is: 5  
}

  • partition()：根据条件分成两个数组

Kotlin 复制代码 
fun main() {  
    val numbers = listOf(1, 2, 3, 4, 5)  
  
    val (evenNumbers, oddNumbers) = numbers.partition { it % 2 == 0 }  
  
    println("Even numbers: $evenNumbers") // 输出：[2, 4]  
    println("Odd numbers: $oddNumbers") // 输出：[1, 3, 5]  
}
  • groupBy()：根据条件将元素分组到不同的数组中
Kotlin 复制代码 
fun main() {  
    val items = listOf("apple", "banana", "cherry", "date", "elderberry")  
  
    val itemGroups = items.groupBy { it.length }  
  
    for ((key, value) in itemGroups) {  
        println("Items with length $key: $value")  
    }  
}

答案输出：
Items with length 5: [apple]
Items with length 6: [banana, cherry]
Items with length 4: [date]
Items with length 10: [elderberry]

  • sum()：计算元素的总和

    Kotlin 复制代码 
    fun main() {  
    val numbers = listOf(1, 2, 3, 4, 5)  
  
    val sum = numbers.sum()  
  
    println("The sum of the numbers is: $sum") // 输出：The sum of the numbers is: 15  
}

  • average()：计算元素的平均值

    Kotlin 复制代码 
    fun main() {  
    val numbers = listOf(1, 2, 3, 4, 5)  
  
    val average = numbers.average()  
  
    println("The average of the numbers is: $average") // 输出：The average of the numbers is: 3.0  
}

  • max()：获取最大元素

Kotlin 复制代码 
fun main() {  
    val numbers = listOf(1, 2, 3, 4, 5)  
  
    val maxNumber = numbers.max()  
  
    println("The maximum number is: $maxNumber") // 输出：The maximum number is: 5  
}
  • min()：获取最小元素
  • reduce()：对元素进行累加
Kotlin 复制代码 
fun main() {  
    val numbers = listOf(1, 2, 3, 4, 5)  
  
    val result = numbers.reduce { acc, num -> acc + num }  
  
    println("The sum of the numbers is: $result") // 输出：The sum of the numbers is: 15  
}
  • fold()：对元素进行累加，并可以指定初始值
Kotlin 复制代码 
fun main() {  
    val numbers = listOf(1, 2, 3, 4, 5)  
  
    val result = numbers.fold(0) { acc, num -> acc + num }  
  
    println("The sum of the numbers is: $result") // 输出：The sum of the numbers is: 15  
}

  • forEach()：遍历元素并执行指定操作

    Kotlin 复制代码 
    fun main() {  
    val numbers = listOf(1, 2, 3, 4, 5)  
  
    numbers.forEach { println(it) }  
}
将会输出以下内容：

1  
2  
3  
4  
5

  • forEachIndexed()：遍历元素并获取索引，执行指定操作

    Kotlin 复制代码 
    fun main() {  
    val numbers = listOf(1, 2, 3, 4, 5)  
  
    numbers.forEachIndexed { index, num -> println("Index $index: $num") }  
}


将会输出以下内容：

Index 0: 1  
Index 1: 2  
Index 2: 3  
Index 3: 4  
Index 4: 5

  • zip()：将两个数组合并成一个新数组，每个元素都是一对。

    Kotlin 复制代码 
    fun main() {  
    val list1 = listOf("a", "b", "c")  
    val list2 = listOf(1, 2, 3)  
  
    val zippedList = list1.zip(list2) { a, b -> Pair(a, b) }  
  
    zippedList.forEach { println(it) }  
}

将会输出以下内容：

复制代码
Pair(a, 1)  
Pair(b, 2)  
Pair(c, 3)

  • all()：判断所有元素是否都满足指定条件

    Kotlin 复制代码 
    fun main() {  
    val numbers = listOf(1, 2, 3, 4, 5)  
  
    val allPositive = numbers.all { it > 0 }  
  
    println("All numbers are positive: $allPositive") // 输出：All numbers are positive: true  
}

  • any()：判断是否有任何元素满足指定条件

    Kotlin 复制代码 
    fun main() {  
    val numbers = listOf(1, 2, -3, 4, 5)  
  
    val hasNegative = numbers.any { it < 0 }  
  
    println("Numbers have negative value: $hasNegative") // 输出：Numbers have negative value: true  
}

  • none()：判断是否所有元素都不满足指定条件

    Kotlin 复制代码 
    fun main() {  
    val numbers = listOf(1, 2, 3, 4, 5)  
  
    val hasNegative = numbers.none { it < 0 }  
  
    println("Numbers have no negative value: $hasNegative") // 输出：Numbers have no negative value: true  
}

  • associate()：将每个元素转化为Pair对象，并返回一个Map

    Kotlin 复制代码 
    fun main() {  
    val numbers = listOf(1, 2, 3, 4, 5)  
  
    val associatedMap = numbers.associate { it to it }  
  
    println("Associated map: $associatedMap")  
}

输出
Associated map: {1=1, 2=2, 3=3, 4=4, 5=5}

  • associateBy()：根据指定条件生成key，并将元素转化为value，返回一个Map

    Kotlin 复制代码 
    fun main() {  
   val people = listOf("David", "Bob", "Charlie", "Alice")
  
    val associatedMap = people.associateBy { it.length }  
  
    println("Associated map: $associatedMap")  
}


Associated map: {5=Alice, 3=Bob, 7=Charlie}

  • associateWith()：将每个元素转化为key，并根据指定条件生成value，返回一个Map

Kotlin 复制代码 
  val people = listOf("Alice", "Bob", "Charlie", "David") 
  val associatedMap = people.associateWith { it.length }  
  println("Associated map: $associatedMap")               
Associated map: {Alice=5, Bob=3, Charlie=7, David=5}
  • flatMapTo()：将每个元素执行指定操作，并将结果合并到一个指定类型的列表中
Kotlin 复制代码 
 val numbers = listOf(1, 2, 3, 4, 5)  
 val flattened = numbers.flatMapTo(HashSet<Int>()) { setOf(it * 2) }
 println("Flattened list: $flattened")
  • mapTo()：将每个元素执行指定操作，并将结果合并到一个指定类型的列表中
Kotlin 复制代码 
val numbers = listOf(1, 2, 3, 4, 5)    
val squaredNumbers = numbers.mapTo(ArrayList<Int>()) { it * it }
println("Squared numbers: $squaredNumbers")

输出结果：Squared numbers: [1, 4, 9, 16, 25]

  • reduceIndexed()：对元素进行累加，并可以访问索引

    Kotlin 复制代码 
    val numbers = listOf(1, 2, 3, 4, 5)

val result = numbers.reduceIndexed { index, acc, value ->
    if (index % 2 == 0) {
        acc + value
    } else {
        acc - value
    }
}

println("Result: $result")
输出结果将会是：

Result: 3

  • foldIndexed()：对元素进行累加，并可以访问索引，并可以指定初始值

    Kotlin 复制代码 
    val numbers = listOf(1, 2, 3, 4, 5)

val result = numbers.foldIndexed(0) { index, acc, value ->
    if (index % 2 == 0) {
        acc + value
    } else {
        acc - value
    }
}

println("Result: $result")

输出结果将会是：Result: 3
相关推荐
黄焖鸡能干四碗18 小时前
信息系统安全保护措施文件方案
大数据·开发语言·人工智能·web安全·制造
liulilittle18 小时前
Unix/Linux 平台通过 IP 地址获取接口名的 C++ 实现
linux·开发语言·c++·tcp/ip·unix·编程语言
Nerd Nirvana19 小时前
C++编程——异步处理、事件驱动编程和策略模式
开发语言·c++·策略模式·嵌入式开发·事件驱动·异步处理
2501_9200470319 小时前
bash自带的切片操作
开发语言·python·bash
前行的小黑炭19 小时前
Android Flow的其他使用：stateIn和冷流(普通Flow)
android·kotlin
会当临20 小时前
【c++】四种类型转换形式
开发语言·c++
tran_sient20 小时前
【Android】制造一个ANR并进行简单分析
android·anr
xxy.c20 小时前
嵌入式解谜日志—多路I/O复用
linux·运维·c语言·开发语言·前端
数据爬坡ing20 小时前
C++ 类库管理系统的分析与设计：面向对象开发全流程实践
java·运维·开发语言·c++·软件工程·软件构建·运维开发
DKPT20 小时前
JVM新生代和老生代比例如何设置？
java·开发语言·jvm·笔记·学习
热门推荐
012025 年高教社杯全国大学生数学建模竞赛C 题 NIPT 的时点选择与胎儿的异常判定 完整成品思路模型代码分享，全网首发高质量！！！022025年数学建模国赛C题超详细解题思路032025全国大学生数学建模C题保姆级思路模型（持续更新）：NIPT 的时点选择与胎儿的异常判定042025高教社杯国赛数学建模选题建议+初步分析052025国赛B题保姆级教程思路分析 碳化硅外延层厚度的确定06UV安装并设置国内源07奈飞工厂官网，国内Netflix影视在线看|中文网页电脑版入口08KGG转MP3工具|非KGM文件|解密音频09（E题｜AI 辅助智能体测）2025年高教杯全国大学生数学建模国赛解题思路|完整代码论文集合10不再让Windows更新！&Edge游戏助手卸载及关闭自动更新