kotlin之plus、copyOf、reverse、forEach、filter、map、reduce、fold等函数解释和使用

本文深入探讨Kotlin中的数组操作与函数调用技巧,包括plus、copyOf、reverse等数组方法,以及map、reduce、fold等高阶函数的应用。通过示例代码,展示如何高效处理数组和自定义函数行为。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

kotlin之::函数调用、plus(增加元素)、copyOf(复制数组)、reverse(翻转数组)、forEach(遍历数组)、filter(过滤数组)、map函数操作及扩展、reduce函数、fold函数、filter、filterIndexed、takeWhile、infix关键字等的解释和使用示例。

说明已经在代码里面了,请看代码。如果有任何疑问或者建议,可以留言。谢谢。

函数的其它用法::,操作函数的其它方式。

class ComposeCall {
    fun sayHi() {
        System.out.println("ComposeCall,sayHi:Hi!")
    }

    fun sayHiToAny(any: Any) {
        System.out.println("--->ComposeCall,sayHiToAny:Hi," + any)
    }
}
复制代码

验证

    var hi1 = ComposeCall::sayHiToAny//返回的是方法本身,而不是返回值
    println("hil:" + hi1)
    //输出
//    hil:fun com.tanksu.ndkdemo3.feature.cls.ComposeCall.sayHiToAny(kotlin.Any): kotlin.Unit

    var hi2 = ComposeCall::sayHi
    var com = ComposeCall()
    hi2(com)//必须要传入类的实例才能够进行调用,相当于java的invoke一样
    hi1(com, "jack")//传入类实例和参数,相当于java的invoke方法,去调用hi2,以及入参
    //输出
//        ComposeCall,sayHi:Hi!
//        --->ComposeCall,sayHiToAny:Hi,jack
复制代码

数组操作之plus(增加元素)、copyOf(复制数组)、reverse(翻转数组)、forEach(遍历数组)、filter(过滤数组)等方法对数组的操作。

        val arr = arrayOf("Apple", "Banana", "", "Orange")
        arr.forEach(::println)//空对象也输出了
        println("--------------------------")
        var narr = arr.plus("juice")//这里必须用另外一个对象来接收,原来的对象不会改变
        var newArr = narr.copyOf()//复制一份新的arr
        newArr.forEach(::println)
        println("--------------------------")
        arr.reverse()//将数组翻转过来
        arr.forEach(::println)
        println("--------------------------")
        println(arr.filter(String::isNotEmpty))//filter将会过滤不为空的对象
//        Apple
//        Banana
//
//        Orange
//        --------------------------
//        Apple
//        Banana
//
//        Orange
//        juice
//        --------------------------
//        Orange
//
//        Banana
//        Apple
//        --------------------------
//        [Orange, Banana, Apple]
复制代码

list的map函数操作及扩展,对数组进行自定义操作。

    val raw = listOf(1, 2, 3, 4, 5, 5)
    val newList = ArrayList<Int>()
    raw.forEach {
        newList.add(it + 1)//it替代raw中每一个元素,这里一次加入到newList中
    }
    println(newList)
    println(raw.map { it * 10 })//map先遍历raw的元素,然后再执行打印动作
    println(raw.map(Int::toDouble))//map先将每个元素都变成double类型,然后再执行打印动作
//        [2, 3, 4, 5, 6, 6]
//        [10, 20, 30, 40, 50, 50]
//        [1.0, 2.0, 3.0, 4.0, 5.0, 5.0]
复制代码

数组的reduce函数:遍历数组元素,并自定义操作。和fold类似。

        val list = listOf(2, 3, 5)
        println(list.reduce { ret, i -> ret + i })//第一个参数ret是结果,第二个参数是代表要执行的操作,
        // 比如我这里是数组每个元素相乘,最后吧结果输出给ret。。。。下面我将进行加法操作,如下
        //输出:30
        //加法操作
        println(list.reduce { ret, i -> ret + i })
        //输出:10
复制代码

数组的fold函数用法:对数组进行进行自定义操作。和reduce类似。

    val list = listOf(2, 3, 5)
    println("--------------------------")
    println(raw.fold(10) { ret, i -> ret + i })//这里给了一个初始值10,然后fold操作和reduce操作类似
    println(raw.fold(StringBuilder("jack say:")) { ret, i -> ret.append(i) })//这里也给了一个初始值StringBuilder
    // ,在第二个参数里面才能够进行append操作
    //输出结果
//        --------------------------
//        20
//        jack say:235
复制代码

数组方法之filter、filterIndexed、takeWhile等对数组元素操作。

        val list = listOf(4, 3, 2, 5, 6, 8, 9)
        println(list.filter { it == 3 || it == 6 })//过滤等于3或者等于6的元素集合,结果以新的集合返回
        println(list.filterIndexed { index, i -> index == i })//过滤等于第一个参数的元素集合,结果以新的集合返回
        println(list.takeWhile { it in 0..5 })//过滤在0-5之间的元素,结果以新的集合返回
        println(list.takeWhile { it in 3..5 })//过滤在3-5之间的元素,结果以新的集合返回。这里加入判断到其中一个元素不满足条件,就会终止执行下面的元素判断
        //输出结果
//        [3, 6]
//        [2]
//        [4, 3, 2, 5]
//        [4, 3]
复制代码

infix的关键字解释:函数的另外一种调用手法。(骚操作)

        class TestInfix(var age: Int) {
            infix fun dog(weight: Int) {
                println("TestInfix, dog $age and $weight")
            }

            infix fun cat(weight: String) {
                println("TestInfix, dog $age and $weight")
            }
        }

        infix fun TestInfix.rat(mounth: Int) {//这是
            println("TestInfix rat $age and $mounth")
        }

        var i = TestInfix(3)
        i dog 80
        i rat 1
        i cat "jack"
//        TestInfix, dog 3 and 80
//        TestInfix rat 3 and 1
//        TestInfix, dog 3 and jack
复制代码

非空判断:

用 ? 调用是安全调用,在被调用的量为空时也返回null
用 !! 调用的是假定非空调用,在被调用的量为空时会发起空指针异常(NPE)
或者直接用条件判断(if-else)来事先决定好空量的处理方案
复制代码
<think>嗯,用户问的是Kotlin在Android开发mapforEach的区别用法比较。之前他提供的引用里提到了KotlinforEach在Android中的注意事项,比如退出循环的问题,还有map遍历时可能遇到的问题。需要结合这些信息来回答。 首先,我应该明确mapforEachKotlin中的基本区别。map是转换集合元素,返回新集合,而forEach只是遍历执行操作,没有返回值。用户可能想知道它们在实际开发中的使用场景常见问题。然后,用户提到的引用里提到,在forEach使用return会直接退出外层函数,这可能导致误解。需要强调这一点,说明如何正确使用标签或者替代方案来退出循环。另外,引用中的map遍历问题,比如参数处理,可能需要指出mapforEach在处理键值对时的不同语法。接下来,我需要考虑用户可能的实际应用场景。比如数据处理时选择map转换数据结构,或者用forEach执行副作用操作,如更新UI或日志。同时,性能方面,map会生成新集合,可能影响内存,而forEach更轻量,但无法链式调用。 还要注意用户提到的Android开发环境,可能涉及集合处理的高效用法,比如对大型数据集的处理建议。另外,错误处理方面,在mapforEach中的异常捕获方式是否有差异,比如在lambda中的try-catch。最后,生成相关问题,帮助用户深入理解,比如如何中断forEach循环,或者性能优化的方法。确保引用标记正确,比如引用[^2]关于退出循环的问题,引用[^3]关于map遍历的问题。</think>### Kotlin Android开发中`map`与`forEach`的区别及用法比较 --- #### 一、核心区别 | **特性** | **map** | **forEach** | |-----------------|----------------------------------|---------------------------------| | **返回值** | 返回新集合(元素类型可转换) | 无返回值(`Unit`) | | **副作用** | 应避免副作用(纯函数) | 专门用于执行副作用[^1] | | **链式调用** | 支持与其他集合操作组合使用 | 仅作为终端操作 | | **循环中断** | 无法直接中断 | 无法直接中断(需异常或标签)[^2] | --- #### 二、具体用法对比 ##### 1. 基本语法 ```kotlin val numbers = listOf(1, 2, 3) // map:转换元素 val squares = numbers.map { it * it } // [1,4,9] // forEach:执行操作 numbers.forEach { println(it) } // 输出1,2,3 ``` ##### 2. 键值对遍历(Map集合) ```kotlin val map = mapOf("a" to 1, "b" to 2) // map遍历需明确参数 val keys = map.map { (k, v) -> k } // ["a","b"] // forEach可直接解构 map.forEach { (k, v) -> println("$k:$v") } // 输出a:1, b:2[^3] ``` ##### 3. 中断循环的差异 ```kotlin // map无法中断转换过程 numbers.map { if (it == 2) return@map // 仅跳过当前元素,继续处理下一个 it * 2 } // forEach使用return会直接退出外层函数 fun processList() { numbers.forEach { if (it == 2) return // 直接退出processList函数! } } ``` **中断替代方案**: - 使用`run`块+标签限制作用域 - 改用`for`循环实现`break` --- #### 三、典型应用场景 | **方法** | **适用场景** | **示例** | |-----------|-------------------------------------------------|----------------------------------| | `map` | 数据格式转换、对象映射、数学计算 | `userList.map { it.name }` | | `forEach` | UI更新、日志记录、状态修改 | `views.forEach { it.visibility = View.GONE }`[^1] | **Android开发示例**: ```kotlin // 数据转换:提取RecyclerView项的数据模型 val itemModels = dataList.map { ItemModel(it.id, it.title) } // 副作用操作:批量设置控件点击事件 buttons.forEach { button -> button.setOnClickListener { /*...*/ } } ``` --- #### 四、性能与注意事项 1. **内存开销** - `map`会生成新集合,大数据集需注意内存占用 - `forEach`直接操作原集合,适合轻量级遍历[^1] 2. **链式调用优化** ```kotlin // 链式操作避免中间集合 dataList.asSequence() .filter { it.isValid } .map { it.toModel() } .forEach { cache.add(it) } ``` 3. **错误处理差异** ```kotlin // map中需捕获单个元素的异常 safeList.map { try { parse(it) } catch (e: Exception) { null } } // forEach中异常会终止遍历 list.forEach { check(it != null) { "元素为空" } // 抛出异常则停止遍历 } ``` --- ### 相关问题 1. 如何在Kotlin的`forEach`中实现类似`break`的功能? 2. 使用`mapNotNull`与`filter`+`map`组合有何性能差异? 3. 为什么在Android开发中推荐使用`asSequence`处理大型集合? 4. Kotlin集合操作与Java Stream API在Android中的性能对比? 5. 如何通过`mapIndexed`实现带索引的数据转换? --- ### 引用 [^1]: Kotlin集合操作在Android中的性能优化实践 [^2]: Kotlin高阶函数中`return`语句的作用域问题 [^3]: Map集合遍历时的解构语法糖与类型推断机制
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值