kotlin学习（4）-高阶函数

（1）基本概念：

高阶函数：传入或者返回函数的函数，函数引用 ： ::println()

package 高阶函数

fun main(args: Array<String>) {

    //::函数引用第一种,直接加方法名
    args.forEach(::print)

    //类名::方法名
    args.filter (String::isNotEmpty)


    //实例名::方法名
    val hello=Hello()
    args.forEach (hello::world)

}
class Hello{
    fun world(any: Any){
        kotlin.io.println(any)
    }
}

（2）常见高阶函数

1.map 一个集合改变元素后成为另一个集合

 val form = listOf(1,2,3,4,5)

 val newForm =  form.map { it+10 }

2.reduce 求和，阶乘

    val  mulList = listOf(1,2,3,4)
    val mul = mulList.reduce { acc, i -> acc * i }

    print(mul)

3.apply任意调用该对象的任何方法，并返回该对象

//apply任意调用该对象的任何方法，并返回该对象
    val task=Runnable{ println("运行中")}
    Thread(task).apply { isDaemon = true }.start()

    val ss="dadas".toUpperCase()
    println(ss.apply { isNotEmpty()})

4.let默认当前这个对象作为闭包的it参数，返回值是函数里的最后一行或者指定return

//let默认当前这个对象作为闭包的it参数，返回值是函数里的最后一行或者指定return
    println("dsadas".let {
        println(it)
        999
    })

5.with可以调用当前对象所有方法

  println(with("dadsad"){
        toUpperCase()
    }.let {it.toLowerCase()})

6.run和apply很像，不过run是将最后一行返回

  ArrayList<String>().run {
        add("123")
        add("223")
        add("323")
        println(this.joinToString())

    }

7.use 可以安全的关闭任何一个可closeable对象

 //use 可以安全的关闭任何一个可closeable对象
    var input=Files.newInputStream(Paths.get("input.txt"))
    var byte=input.use ({ input.read() })

(3)尾递归优化

递归的一种特殊形式，调用自身后无其他操作，tailrec关键字提示编译器尾递归优化

package 高阶函数

class ListNode(var value:Int,var next:ListNode?=null)

tailrec fun findNode(head:ListNode?,value:Int):ListNode?{
    head?:return null
    if (value==head.value) return head
    return findNode(head.next,value)
}

fun main(args: Array<String>) {
    val MAX_NUM=100000
    var head=ListNode(0)
    var p=head
    for (i in 1..MAX_NUM){
        p.next= ListNode(i)
        p= p.next!!
    }

    println(findNode(head,MAX_NUM-2)!!.value)
}

（4）闭包：函数运行的环境，持有函数运行状态，函数内部可以定义函数或者类

package 高阶函数

val string="HelloWorld"

fun makefun():()->Unit{
    var count=0
    return fun(){
        println(++count)
    }
}

fun fibonacci():()->Long{
    var first=0L
    var second=1L
    return fun():Long{
        val result=second
        second+=first
        first=second-first
        return result
    }
}

fun fibonacciw():Iterable<Long>{
    var first=0L
    var second=1L
    return Iterable{
        object : LongIterator() {
            override fun hasNext()=true

            override fun nextLong(): Long {
                val result=second
                second+=first
                first=second-first
                return result
            }
        }
    }
}

fun main(args: Array<String>) {
//    fibonacciw().takeWhile { it <= 100 }.forEach { println(it) }


    val add5= add(5)
    println(add5(2))
}


fun add(x:Int)=fun (y:Int)=x+y

（5）demo 统计字符串个数

package 高阶函数

import java.io.File

fun main(args: Array<String>) {

    val  map=HashMap<Char,Int>()
    val text=File("KtTest.iml").readText().toCharArray().filterNot(Char::isWhitespace).forEach{
        val count=map[it]
        if (count==null) map[it]=1
        else map[it]=count+1
    }

    map.forEach(::println)
}