总结 Kotlin常用的高阶函数（forEach,map,flatmap,fold,reduce,filter,takeWhite,let/run,also/apply,with,use）

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

/**
 * 对集合每一个元素做变换
 */
fun map() {
    val arr = intArrayOf(1, 2, 4, 6)

    arr.map {
        "$it nihao"
    }.forEach(::println)

}

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

}

/**
 * 对数组中每个元素变化，铺平后，装进一个新的集合
 */
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)
    }


/*    arr.flatMap {
        listOf(it + 1)
    }.forEach {
        println(it)
    }*/

}

/**
 * 从集合左到右，依次计算每个元素累加的结果。
 */
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"
    })
}

/**
 * 从[初始]值开始累加值，并从左到右对当前累加器值和每个元素应用[操作]。
 * 与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和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 是集合从后往前过滤
}

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

/**
 * 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)
}

/**
 * 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) }
}

/**
 * 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)
}


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

}

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

}