（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)
}