Kotlin 高阶函数和Lambda（总结）

Kotlin 函数都是头等的，这意味着它们可以存储在变量与数据结构中、作为参数传递给其他高阶函数以及从其他高阶函数返回。

  /**
     * 方法内部定义局部方法
     */
    fun test1(){
        fun testSub(value:Int):Int{
           return value*3
        }
        print("this is subMethod value=${testSub(4)}")
    }

高阶函数是将函数用作参数或返回值的函数。

1.函数类型

Kotlin 使用类似 (Int) -> String 的一系列函数类型来处理函数的声明

• 所有函数类型都有一个圆括号括起来的参数类型列表以及一个返回类型：(A, B) -> C 表示接受类型分别为 A 与 B 两个参数并返回一个 C 类型值的函数类型。 参数类型列表可以为空，如 () -> A。Unit 返回类型不可省略。

  (Int)-> Int
  //参数可为null
  (code:Int?)-> Int
  
  //整个函数类型也可为null
  ((code:Int?)-> Int)？
  

• 函数类型可以有一个额外的接收者类型，它在表示法中的点之前指定： 类型 A.(B) -> C 表示可以在 A 的接收者对象上以一个 B 类型参数来调用并返回一个 C 类型值的函数。 带有接收者的函数字面值通常与这些类型一起使用。

fun <T, R> Collection<T>.fold(
    initial: R, 
    combine: (acc: R, nextElement: T) -> R
): R {
    var accumulator: R = initial
    for (element: T in this) {
        accumulator = combine(accumulator, element)
    }
    return accumulator
}
//参数 combine 具有函数类型 (R, T) -> R，因此 fold 接受一个函数作为参数， 
//该函数接受类型分别为 R 与 T 的两个参数并返回一个 R 类型的值。 在 for-循环内部调用该函数，然后将其返回值赋值给 accumulator。

• [挂起函数]属于特殊种类的函数类型，它的表示法中有一个 suspend 修饰符 ，例如 suspend () -> Unit 或者 suspend A.(B) -> C。

可以通过使用[类型别名]给函数类型起一个别称：

typealias ClickHandler = (Button, ClickEvent) -> Unit

2.函数类型实例化

有几种方法可以获得函数类型的实例：

1. [lambda 表达式] { a, b -> a + b },
2. 匿名函数： fun(s:String):Int { return s.toIntOrNull() ?: 0 }
3. 带有接收者的函数字面值可用作带有接收者的函数类型的值。
4. 使用实现函数类型接口的自定义类的实例：

class IntTransformer: (Int) -> Int {
    override operator fun invoke(x: Int): Int = TODO()
}

val intFunction: (Int) -> Int = IntTransformer()

5. 带与不带接收者的函数类型非字面值可以互换，其中接收者可以替代第一个参数，反之亦然。例如，(A, B) -> C 类型的值可以传给或赋值给期待 A.(B) -> C 的地方，反之亦然：

fun main() {
    val repeatFun: String.(Int) -> String = { times -> this.repeat(times) }
    val twoParameters: (String, Int) -> String = repeatFun // OK

    fun runTransformation(f: (String, Int) -> String): String {
        return f("hello", 3)
    }
    val result = runTransformation(repeatFun) // OK

    println("result = $result")
}

3.函数类型实例调用

函数类型的值可以通过其 invoke(……) 操作符调用：f.invoke(x) 或者直接 f(x)。如果该值具有接收者类型，那么应该将接收者对象作为第一个参数传递。 调用带有接收者的函数类型值的另一个方式是在其前面加上接收者对象， 就好比该值是一个扩展函数：

val stringPlus: (String, String) -> String = String::plus
val intPlus: Int.(Int) -> Int = Int::plus

println(stringPlus.invoke("<-", "->"))
println(stringPlus("Hello, ", "world!")) 

println(intPlus.invoke(1, 1))
println(intPlus(1, 2))
println(2.intPlus(3)) // 类扩展调用

4.高阶函数实践

4.1 可以代替接口回调

java以往通过接口回调来传递数据

public interface IUpdateListener{
     void updateItem(int index);
}
public class B {
	  void testClick(){
        if (iUpdateListener!=null){
            iUpdateListener.updateItem(9);
        }
    }
    IUpdateListener iUpdateListener;
    public void setiUpdateListener(IUpdateListener iUpdateListener) {
        this.iUpdateListener = iUpdateListener;
    }
}

public class A {
    void testMethod(){
        B b = new B();
        b.setiUpdateListener(new B.IUpdateListener() {
            @Override
            public void updateItem(int index) {
                //TODO 接收调用的地方
            }
        });
    }
}

现在使用kotlin 高阶函数,iUpdateListener:(View)->Unit,代替接口回调，不用声明接口对象。这种情况只适合单个方法。

iUpdateListener:函数的引用

(View)->Unit：函数体，左边是view 右边是返回值

class A {
    fun getView(view: View, iUpdateListener:(View)->Unit){
        view.setOnClickListener { 
            iUpdateListener.invoke(it)
        }
    }
}
class B {
    fun testLambda() {
        A().getView(TextView(context), {
            //TODO 此处接收A类的调用            
        })
    }
}

4.2 把筛选条件抽象为高级函数

	fun filterCountries(
			countries: List<Country>,
			test: (Country) -> Boolean): List<Country> // 增加了一个函数类型的参数test
	{
		val res = mutableListOf<Country>()
		for (c in countries) {
			if (test(c)) { // 直接调用test来进行筛选
				res.add(c)
			}
		}
		return res
	}

	val countryApp = CountryApp()
	val countryTest = CountryTest()
	val countries = listOf(Country("China", "Asia", 1300000000))
	//方法引用countryTest::isBigEuropeanCountry  
	countryApp.filterCountries(countries, countryTest::isBigEuropeanCountry)
  //匿名函数
	countryApp.filterCountries(countries, fun(country: Country): Boolean {
		return country.continient == "EU" && country.population > 10000
	})
	//lambda表达式
	countryApp.filterCountries(countries, { country ->
		country.continient == "EU" && country.population > 10000
	})

kotlin 可以使用两个冒号来引用类的方法

5.Lambda 表达式与匿名函数

lambda 表达式与匿名函数是“函数字面值”，即未声明的函数，

max(strings, { a, b -> a.length < b.length })

函数 max 是一个高阶函数，第二个参数是一个函数。 也是一个表达式，即函数字面值，它等价于以下具名函数：

fun compare(a: String, b: String): Boolean = a.length < b.length
 
val sum: (Int, Int) -> Int = { x: Int, y: Int -> x + y }

lambda 表达式必须使用{}包裹， 完整语法形式的参数声明放在花括号内，并有可选的类型标注， 函数体跟在一个 -> 符号之后。如果推断出的该 lambda 的返回类型不是 Unit，那么该 lambda 主体中的最后一个（或可能是单个） 表达式会视为返回值。

如果我们把所有可选标注都留下，看起来如下：

val sum = { x: Int, y: Int -> x + y }

5.1 传递末尾的 lambda 表达式

在 Kotlin 中有一个约定：如果函数的最后一个参数是函数，那么作为相应参数传入的 lambda 表达式可以放在圆括号之外：

val product = items.fold(1) { acc, e -> acc * e }

这种语法也称为拖尾 lambda 表达式。

5.2 it：单个参数的隐式名称

如果编译器自己可以识别出签名，也可以不用声明唯一的参数并忽略 ->。 该参数会隐式声明为 it：

ints.filter { it > 0 } // 这个字面值是“(it: Int) -> Boolean”类型的

5.3 从 lambda 表达式中返回一个值

ints.filter {
    val shouldFilter = it > 0 
    shouldFilter
}

ints.filter {
    val shouldFilter = it > 0 
    return@filter shouldFilter
}

5.4 下划线用于未使用的变量

map.forEach { _, value -> println("$value!") }

5.5 匿名函数

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

6.返回值为函数和柯里化

一个函数也可以作为另一个函数的结果。

    fun testReturnValue(x:Int): (Int) -> Unit {
        return { y: Int -> x + y }
    }
 

柯里化：指接收多个参数的函数变换成一系列仅接收单一参数函数的过程。前面的函数依次接收单个参数，然后返回下一个新的函数。它的出现为了简化函数接收多个参数而出现的。

fun sum(x:Int)={ y:Int ->
    { z:Int ->
        x+y+z
    }
}
sum(1)(2)(3)