Kotlin之高阶函数

forEach 遍历

fun main(args: Array<String>) {
    var list = listOf(1, 2, 3, 4, 5, 6)
    list.forEach(::println)

    val newList = arrayListOf<String>() --->1,2,3,4,5,6

    list.forEach {
        newList.add((it * 2).toString()) --->2,4,6,8,10,12
    }
    
    newList.forEach(::println)
}

map 变换

fun main(args: Array<String>) {
    val list = listOf(1, 2, 3, 4, 5, 6)

    val newList = list.map {
        //对集合中的数据进行操作，然后赋值给新的集合
        (it * 2).toString()
    }.forEach(::println) //2 4 6 8 10 12

    val doubleList = list.map {
        it.toDouble()
    }.forEach(::print) //1.0 2.0 3.0 4.0 5.0 6.0
    //函数作为参数的第二种方式调用 类名::方法名
    val doubleList2 = list.map(Int::toDouble).forEach(::print) 1.0 2.0 3.0 4.0 5.0 6.0

}

flatMap 对集合的集合进行变换

fun main(args: Array<String>) {
    val list = arrayOf(
        1..5,
        50..55
    )

    //把多个数组集合变成一个数组，并且对数据进行变换
    val mergeList = list.flatMap { intRange -> //集合内的集合 1..5 , 50..55
        intRange.map { intElement -> //集合内集合遍历 1,2,3,4,5
            "No.$intElement"
        }
    }
    //No.1 , No.2 , No.3 , No.4 , No.5 , No.50 , No.51 , No.52 , No.53 , No.54 , No.55 ,
    mergeList.forEach { print("$it , ") }

    println()
    //直接多个数组集合变换成一个结集合
    val newList = list.flatMap {
        it
    }
    //1 , 2 , 3 , 4 , 5 , 50 , 51 , 52 , 53 , 54 , 55 ,
    newList.forEach { print("$it , ") }
}

reduce ，fold，foldRight 倒叙, joinToString转换字符去

fun main(args: Array<String>) {
    val list = arrayOf(
        1..5,
        2..3
    )

    val newList = list.flatMap {
        it
    }
    //1 , 2 , 3 , 4 , 5 , 50 , 51 , 52 , 53 , 54 , 55 ,
    newList.forEach { print("$it , ") }

    //求和 reduce 返回值必须是 acc类型
    println(newList.reduce { acc, i -> acc + i }) //20

    //带基数求和
    println(newList.fold(10) { acc, i -> acc + i }) //30


    //fold 返回值类型是 "基数" 对应的类型,比如 StringBuilder hello--1--2--3--4--5--2--3--
    println(newList.fold(StringBuilder("hello--")) { acc, i -> acc.append(i).append("--") }) //30

    //拼接字符串 1---, 2---, 3---, 4---, 5---, 2---, 3---
    println(newList.joinToString { "$it---" })
    
}

filter 筛选 filterIndexed 下标筛选

fun main(args: Array<String>) {
    val list = arrayOf(
        1..5,
        2..3
    )
    val newList = list.flatMap {
        it
    }
    //筛选 集合中数据 > 2的item
    val filterList = newList.filter { it > 2 }
    filterList.forEach(::print) //3453
    //筛选 集合中下标是奇数item
    val filterIndexList = newList.filterIndexed { index, i -> index % 2 == 0; }
    filterIndexList.forEach { print(it) } //1 3 5 3
}

takeWhile 截至条件

fun main(args: Array<String>) {
    val list = arrayOf(
        1..5,
        2..3
    )
    val newList = list.flatMap {
        it
    }
    //截取符合条件的前面的所以的item 1234523，< 3 ，12
   // newList.takeWhile { it < 3 }.forEach { print(it) } // 1 2

    //返回包含 最后[n]元素 的列表。，包含最后2个元素
    newList.takeLast(2).forEach(::print) // 23
}

?. 判空执行，let 类作为参数，apply 类扩展

fun main(args: Array<String>) {
    val person = getPerson()
    println(person?.name) //判空处理，如果不为空 执行后面的方法

    person?.let { //类作为参数 it
        println(it.name)
        println(it.age)
        it.work()
    }

    person?.apply { //类扩展 可以直接调用
        println(name)
        println(age)
        work()
    }
}

fun getPerson(): Person? {
    return Person("shadow", 18)
}

class Person(val name: String, val age: Int) {
    fun work() {
        println("hello shadow")
    }
}

with

定义：fun <T, R> with(receiver: T, block: T.() -> R): R
功能：将对象作为函数的参数，在函数内可以通过 this指代该对象。返回值为函数的最后一行或return表达式。

fun main(args: Array<String>) {
    val br = BufferedReader(FileReader("shadow.txt"))
    br.readLine()
    br.read()
    //使用给定的[receiver]调用指定的函数[block]并返回其结果。
   /* with(br) {
        var readLine: String?
        while (true) {
            readLine = readLine() ?: break //如果不为空 就执行前面的表达式 否则执行后面的表达式
            println(readLine)
        }
        close()
    }*/
}

user

use函数会自动关闭调用者（无论中间是否出现异常）
Kotlin的File对象和IO流操作变得行云流水
use函数内部实现也是通过try-catch-finally块捕捉的方式，所以不用担心会有异常抛出导致程序退出
close操作在finally里面执行，所以无论是正常结束还是出现异常，都能正确关闭调用者

  BufferedReader(FileReader("build.gradle")).use {
        var readLine: String?
        while (true) {
            readLine = readLine() ?: break //如果不为空 就执行前面的表达式 否则执行后面的表达式
            println(readLine)
        }
    }

闭包函数

闭包函数 一个函数的返回值是函数，函数的内部包含另一个函数，可以是有参无参的匿名函数

fun main(args: Array<String>) {
    val mm = aaa()
    println(mm())
    println(mm())
    println(mm())
    println(mm())
    println(mm())

    val  kk = bbb()
    println(kk("shadow")) //shadow --- 1
    println(kk("shadow")) //shadow --- 2
    println(kk("shadow")) //shadow --- 3
    println(kk("shadow")) //shadow --- 4
    println(kk("shadow")) //shadow --- 5

}

//闭包函数 就是函数作为返回参数
fun aaa(): () -> (Int) {
    var current = 10
    return fun(): Int {
        return current++
    }
}

fun bbb(): (String) -> (String) {
    var current = 0;
    return fun(str: String): String {
        current++;
        return "$str --- $current";
    }
}

原文地址：https://www.jianshu.com/p/27ed7e4e1259