高阶函数 （forEach、map、flatmap,filter）

• forEach

    /**
     * 遍历函数
     */
    fun forEach() {
        val arr = intArrayOf(1, 2, 4, 6)
        arr.forEach(::println)
    }
  

• map

    /**
     * 对集合每一个元素做变换
     */
    fun map() {
        val arr = intArrayOf(1, 2, 4, 6)
     
        arr.map {
            "$it nihao"
        }.forEach(::println)
     
    }
  

• flatmap

    /**
     * 对数组中每个元素变化，铺平后，装进一个新的集合
     */
    fun flatMap() {
     
        val arr = intArrayOf(1, 2, 4, 6)
        val arr2 = intArrayOf(10, 39, 39, 18, 88)
        var arr3 = intArrayOf(100, 200, 383, 198)
     
        val newArr = arrayListOf(arr, arr2, arr3)
        newArr.flatMap { iterator ->
            iterator.map {
                it.toString() + "haha"
            }
        }.forEach {
            println(it)
        }
  

• filter

    /**
     * 根据条件过滤元素
     */
    fun filter() {
        val arr = intArrayOf(1, 2, 4, 6)
        arr.filter {
            it % 2 == 0
        }.forEach(::println)
     
    }
  

高阶函数（reduce、fold、takeWhile）

• reduce

    /**
     * 从集合左到右，依次计算每个元素累加的结果。
     */
    fun reduce() {
        val arr = intArrayOf(1, 2, 4, 6)
    //    求整数的和
        val sum = arr.reduce { acc, i ->
            acc + i
        }
     
        //求阶乘
        val factorial = arr.reduce { acc, i ->
            acc * i
        }
        println(factorial)
     
        //将集合拼接成字符串 0,1,2,3,4,5,6
        println((0..6).map { it.toString() }.reduce { acc, i ->
            "$acc,$i"
        })
    }
  

• fold

    /**
     * 从[初始]值开始累加值，并从左到右对当前累加器值和每个元素应用[操作]。
     * 与reduce类似,reduce没有初始值是第一个元素
     * fold必须手动传一个初始值
     */
    fun fold() {
        val arr = intArrayOf(1, 2, 4, 6)
        val fold = arr.fold(2) { acc, i -> acc + i }
        println(fold)
     
        //将集合拼接成字符串
     
        println((0..6).fold(StringBuilder()) { acc, i ->
            acc.append(i).append(",")
        })
     
    }
  

• takeWhile

     /**
     * takeWhile和filter一样都是过滤用的函数
     * 和filter不同地方在filter总是会遍历当前IntArray的所有元素
     * 而takeWhile在第一次发现predict不满足的时候就不再遍历
     * 后面的元素即使满足条件也不会加入到结果中
     */
    fun takeWhile() {
        val arr = intArrayOf(1, 2, 4, 5, 6)
     
        arr.takeWhile { it % 2 != 0 }
            .forEach(::println)
     
    //    take/takeLast
    //    take是从集合中取前几个元素，takeLast是从集合中取后几个元素。
    //    takeWhile/takeLastWhile
    //    takeLastWhiles 是集合从后往前过滤
    }
  

高阶函数（let、apply、takeIf、With、use）

data class User(var name: String, var age: Int)

• let

/**
 * let 和run 都会返回闭包执行结果，区别在于let有闭包参数，run没有
 */
fun letAndRun() {
    val user = User("littleGreens", 18)
    val let = user.let { user: User -> user.name }
//    val let = user.let {it.name }
    println(let)
 
    val run = user.run { this.name }
    println(run)
}

• apply

/**
 * also apply 都不返回闭包执行结果,返回的是this（调用者），区别在于also有闭包参数，apply没有
 */
fun alsoAndApply() {
    val user = User("littleGreens", 18)
    user.also { user: User -> user.name = "klaus" }
        .apply { println(this.name) }
//    user.also { it.name = "klaus" }
 
    user.apply { this.name = "klausCai" }
        .apply { println(this.name) }
}

• with

/**
 * with可以让用户省略点号之前的对象引用，with内部的所有操作都是针对with对象
 */
fun With() {
    val user = User("littleGreens", 18)
    with(user) {
        println(name)
        name = "klaus"
        println(name)
    }
 
}

• use

/**
 * use是针对那些实现了Closable接口的对象的扩展方法，也就是大部分的IO操作相关类会有这个扩展高阶方法，
 * use内已经捕获了异常，并调用了close方法。
 */
fun Use() {
    val file = File("test.txt")
    val bufferReader = BufferedReader(FileReader(file))
    bufferReader.use {
        it.readLine()
    }
 
}

• takeIf

/**
 * takeIf作为条件过滤，满足条件返回this，否则返回null
 */
fun takeIf() {
    val arr = intArrayOf(1, 2, 4, 5, 6)
    val element = arr.takeIf {
        arr.size > 3
    }?.let {
        it[3]
    }
    println(element)
}