21.Kotlin函数与Lambda表达式

Kotlin函数

默认参数(default arguments)
示例代码

fun test(a: Int = 0, b: Int = 1) = println(a - b)

fun main(args: Array) {
    test()
    test(2)
    test(b = 2) //显示指定参数名
    test(3, 2)
    test(a = 3)
}

输出

-1
1
-2
1
2

对于重写的方法来说,子类所拥有的重写方法会使用与父类相同的默认参数值。
在重写一个拥有默认参数值的方法时,方法签名中必须要将默认参数值省略掉。

示例代码

open class A {
    open fun method(a: Int, b: Int = 4) = a + b
}

class B : A() {
    override fun method(a: Int, b: Int) = a + b
}


fun main(args: Array) {
    println(A().method(1))
    println(B().method(2))
}

输出

5
6

如果一个默认参数位于其他无默认值的参数前面,那么默认值只能通过在调用函数时使用具名参数的方式来使用。

示例代码

fun test2(a: Int = 1, b: Int) = println(a - b)

fun main(args: Array) {
    test2(b = 3) // 具名参数(named argument)
}

输出

-2

如果函数的最后一个参数是lambda表示式,而且在调用是位于圆括号之外,
那么就可以不指定lambda表达式具名参数名。

示例代码

fun test3(a: Int = 1, b: Int = 2, compute: (x: Int, y: Int) -> Unit) {
    compute(a, b)
}


fun main(args: Array) {
    test3(2, 3, ::test)

    test3(2, 3, { a, b -> println(a - b) })

    test3(2, 3) { a, b ->
        println(a - b)
    }

    test3(2) { a, b ->
        println(a - b)
    }

    test3 { a, b ->
        println(a - b)
    }
}

输出

-1
-1
-1
0
-1

具名参数,在调用函数时,函数参数可以是具名的。当一个函数有大量参数或是一些参数拥有默认值时,这种调用方式是比较方便的。

示例代码

fun test4(a: Int, b: Int = 2, c: Int = 3, d: Int) = println(a + b + c + d)

fun main(args: Array) {
    test4(1, 2, 3, 4)

    test4(a = 1, b = 2, c = 3, d = 4)

    test4(a = 1, d = 5)
}

输出

10
10
11

在调用函数时,如果同时使用了位置参数与具名参数,那么所有的位置参数都必须要位于第一个具名参数之前, 比如说,foo(1,x = 2)是允许的;不过foo(x = 1, 2)是不允许的。

对于重写的方法来说,子类所拥有的重写方法会使用与父类相同的默认参数值。在重写一个拥有默认参数值的方法时,方法签名中必须要将默认参数值省略掉。

示例代码

fun test4(vararg strings: String) {
    println(strings.javaClass) // strings的java类型是数组类型
    strings.forEach { println(it) }
}
fun main(args: Array) {
    test4("a", "b", "c")
    //可变参数可以借助于spread operator以具名参数的形式传递
    test4(strings = *arrayOf("a", "b", "c"))
    test4(strings = "a")

    val arrays = arrayOf("a", "b", "c")
    test4(*arrays)
}

输出

class [Ljava.lang.String;
a
b
c
class [Ljava.lang.String;
a
b
c
class [Ljava.lang.String;
a
class [Ljava.lang.String;
a
b
c

在kotlin中调用Java方法时不能使用具名参数语法,因为Java字节码并不会总是会保留方法参数名信息。

单表达式函数,函数的返回类型如果可以通过类型推断判断出来,那么返回类型就可以省了掉。
示例代码

fun add(a:Int,b:Int):Int = a +b

无返回值示例

fun myPrint(name:String):Unit{
    println(name)

    return Unit
}

显示返回类型,拥有方法体的函数必须要显示指定返回类型,除非函数返回Unit,这时返回类型就可以省略掉. Kotlin并不会推断拥有块体的函数的返回类型,因为这种函数可能拥有非常复杂的控制流程,返回类型对于阅读代码的人来说就不是那么明显了(有时,对于编译器来说亦如此)

在一个方法中,只允许一个参数为vararg,通常作为最后一个参数。如果vararg不是最后一个参数,那么其后的参数就需要通过具名参数形式进行传递。如果其后的参数是函数类型,那么还可以通过在圆括号外传递lanbda表达式来实现。

示例代码

fun  conver2List(vararg elements: T): List {

    val result = ArrayList()

    elements.forEach { result.add(it) }

    return result
}

fun main(args: Array) {
    println(conver2List("hello", "world", "hello world"))

    var element = arrayOf("welcome", "bye", "test")

    println(conver2List("zhangsan", "lisi", *element))
}

输出

[hello, world, hello world]
[zhangsan, lisi, welcome, bye, test]

中缀符号(infix notation) ,函数还可以通过中缀符号形式来调用,需要满足如下3个条件:
1.是成员函数或是扩展函数
2.拥有单个参数
3.声明时使用infix关键字

示例代码

class InfixTest(private var a: Int) {
    infix fun add(b: Int) = this.a + b
}

fun main(args: Array) {
    val infixTest = InfixTest(2)

    //以下两种方式等价
    println(infixTest.add(5))
    println(infixTest add 5) //中缀符号调用法
}

输出

7
7

内联函数(inline function)示例代码

inline fun myCalculate(a: Int, b: Int) = a + b

fun main(args: Array) {
    println(myCalculate(1, 2))
}

高级函数(high-order function)与lambda

Lambda表达式要求:
1.一个lambda表达式总是被一对花括号所包围。
2.其参数(如果有的话)位于 -> 之前(参数类型是可以省略掉的)
3.执行体位于 -> 之后

在Kotlin中,如果一个函数的最后一个参数是个函数,那么可以将lambda表达式作为实参传递进去,并且可以在调用时方法圆括号外去使用。

示例代码


val multiply: (Int, Int) -> Int = { a, b -> a * b }
val add: (Int, Int) -> Int = { a, b -> a + b }
val subtract = { a: Int, b: Int -> a - b }
val myAction = { println("hello world") }

val mayReturnNull: (Int, Int) -> Int? = { _, _ -> null }
val functionMaybeNull: ((Int, Int) -> Int)? = null

示例代码

package com.leofight.kotlin5

fun myCalculate(a: Int, b: Int, calculate: (Int, Int) -> Int): Int {
    return calculate(a, b)
}


fun main(args: Array) {

    println(myCalculate(2, 3, { x, y -> x + y }))
    println(myCalculate(2, 3, { x, y -> x - y }))
    println(myCalculate(2, 3, { x, y -> x * y }))


    println(myCalculate(2, 3) { x, y -> x + y })

}

输出

5
-1
6
5

示例代码

package com.leofight.kotlin5


fun String.filter(predicate: (Char) -> Boolean): String {

    val sb = StringBuilder()

    for (index in 0 until length) {
        val element = get(index)

        if (predicate(element)) {
            sb.append(element)
        }
    }

    return sb.toString()
}

fun main(args: Array) {
    var str = "hell7wor19"

    println(str.filter { it.isLetter() })
}

输出

hellwor

示例代码

package com.leofight.kotlin5

fun main(args: Array) {

    val strings = arrayOf("hello", "world", "bye", "helloworlD", "welcome")

    strings.filter { it.contains("h") }.forEach { println(it) }

    println("---------")

    strings.filter { it.length > 4 }.forEach { println(it) }

    println("---------")

    strings.filter { it.endsWith("d", true) }.map { it.toUpperCase() }.forEach { println(it) }
}

在默认情况下,lambda表达式中最后一个表达式值会隐式作为该lambda表达式的返回值,我们可以通过全限定的return语法来显式从lambda表达式返回值。

示例代码


fun main(args: Array) {
    val strings = arrayOf("hello","world","bye")

    strings.filter {
        val mayFilter = it.length > 3
        mayFilter
    }

    strings.filter {
        val mayFilter = it.length > 3

        return@filter mayFilter
    }
}

匿名函数示例代码

fun main(args: Array) {

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

    fun(x: Int, y: Int): Int {
        return x + y
    }

    val strings = arrayOf("hello","world","bye")

    strings.filter(fun(item):Boolean = item.length > 3).forEach(fun(item){ println(item)})


}

闭包示例代码

fun main(args: Array) {
    var sum = ""

    val strings = arrayOf("hello","world","bye")

    strings.filter { it.length > 3 }.forEach {
        sum += it
    }

    println(sum)
}

带有接收者的函数字面值

Kotlin提供了这样一种功能:可以通过指定的接收者对象来调用一个函数字面值,在函数字面值内部,你可以调用接收者对象的方法而无需使用任何额外的修饰符
这一点非常类似于扩展函数。

示例代码

fun main(args: Array) {

    val subtract: Int.(other: Int) -> Int = { other -> this - other }

    println(1.subtract(3))

    println("-------------")

    /*
        匿名函数语法可以让我们指定函数字面值的接收者类型。这样,我们就可以先去声明一个带有接收者的函数类型变量,然后再去使用它
     */

    val sum = fun Int.(other: Int): Int = this + other

    println(1.sum(2))

    println("-------------")

    /*
        带有接收者类型的函数的非字面值可以作为参数进行传递,前提是所需要接收函数的地方应该有一个接收者类型的参数,反之亦然。
        比如说:类型 String.(Int) -> Boolean 与(String,Int) -> Boolean 等价
     */

    val myEquals: String.(Int) -> Boolean = { param -> this.toIntOrNull() == param }

    println("456".myEquals(456))

    println("------------")

    fun myTest(op: (String, Int) -> Boolean, a: String, b: Int, c: Boolean) = println(op(a, b) == c)

    myTest(myEquals, "200", 200, true)
}

你可能感兴趣的:(21.Kotlin函数与Lambda表达式)