Kotlin声明高阶函数

最新推荐文章于 2024-08-18 16:05:26 发布

spy_develop

最新推荐文章于 2024-08-18 16:05:26 发布

阅读量2.6k

点赞数 1

分类专栏： kotlin 文章标签： Kotlin lambda 高阶函数

本文链接：https://blog.csdn.net/spy_develop/article/details/79470624

版权

kotlin 专栏收录该内容

8 篇文章 1 订阅

订阅专栏

Kotlin声明高阶函数

1.函数类型

把lambda表达式保存在局部变量中：

   val sum={x:Int,y:Int->x+y}
   val action={ println(42)}

在这个例子中，编译器推导出sum和action两个变量具有函数类型。我们再看看这些变量的显示类型声明是什么样的：

    val sum:(Int,Int)->Int={x,y->x+y}
    val action:()->Unit={ println(42)}

声明函数类型，需要将函数参数类型放在括号中，紧接着是一个箭头和函数的返回类型。

Unit类型用于表示函数不返回任何返回值。在声明一个普通函数时，Unit类型的返回值是可以省略的，但是一个函数类型的声明总是需要一个显示的声明类型，所以在这种场景下Unit是不能省略的。

lambda表达式中{x,y->x+y}中是可以省略参数x，y的类型的，应为它们的类型已经在函数类型的变量声明部分指定了，不需要在lambda中去重复声明。

函数的返回值也可以标记为可空类型。

var canReturnNull: (Int, Int) -> Int? = { null }

可以定义一个函数类型的可空变量。为了明确表示是变量本身可空，而不是函数类型的返回类型可空，你需要将整个函数类型的定义包含在括号内并在括号后加一个问号：

 var funOrNull: ((Int, Int) -> Int)? = null

这个例子和前一个例子有微妙的区别。如果省略了括号，声明的将会是一个返回值可空的函数类型，而不是一个可空的函数类型变量。

2.调用作为参数的函数

定义一个简单高阶函数

  fun twoAndThree(operation: (Int, Int) -> Int) {
      val result = operation(2, 3)
      LogS(result)
   }
   twoAndThree { a, b -> a + b }//5
   twoAndThree { a, b -> a * b }//6

调用作为参数的函数和调用普通函数的方法是一样的：filter函数。为了让事情简单起来。将实现基于String类型的filter该函数，但和作用于集合的泛型版本的原理是相同的：

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

filter函数以一个判断式作为参数。判断式的类型是一个函数，以字符作为参数并返回boolean类型的值。如果要让传递给判断式的字符出现在最终返回的字符串中，判断式需要返回true，反之返回false。

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

    LogS("aBc12c".filter { it in 'a'..'z' })//acc

filter函数实现非常简单。它检查了每个字符是否满足判断式，如果满足就将字符添加到包含结果的StringBuilder中。

3.在Java中使用函数类

在Java中可以很简单的调用使用函数类型的kotlin函数。Java8的lambda会被自动转换为函数类型的值。

   /*kotlin声明*/
    fun processsTheAnswer(f:(Int)->Int){
        LogS(f(42))
    }

    /*java调用*/
    processsTheAnswer(number->number+1)

在旧版Java中，可以传递一个实现了函数接口中的invoke方法的匿名类的实例：

   /*java*/
        processsTheAnswer(
                new Function<Integer,Integer>(){
                    @Override
                    public Integer invoke(Integer number){
                        Logs(number);
                        return number+1;
                    }
                }
        )

在Java中可以容易的使用Kotlin标准库中以lambda作为参数的拓展函数。但是注意它们看起来并没有Kotlin中那么直观———必须要显示地传递一个接受者对象作为第一个参数。

4.函数类型的参数默认值和null

声明函数类型的参数的时候可以指定参数的默认值。要知道默认值的用处，我们回头看一看joinToString函数：

   fun <T> Collection<T>.joinToString(
            separator: String = ",",
            prefix: String = "",
            postfix: String = ""
    ): String {
        val result = StringBuilder(prefix)
        for ((index, element) in this.withIndex()) {
            if (index > 0) result.append(separator)
            result.append(element)
        }
        result.append(postfix)
        return result.toString()
    }

这个实现很灵活，但是它没有让你控制转换的关键点：集合中的元素如何转换为字符串的。代码中使用了StringBuilder.append(0:Any?),它总使用toString方法将对象转换为字符串。在大多数情况下这样就可以了。但并不总是这样。我们现在已经知道可以传递一个lambda去指定如何将对象转换为字符串。但要求所有调用者都传递lambda是比较烦人的事情，因为大部分调用使用默认行文就可以了。为了解决这个问题，可以定义一个函数类型的参数并用一个lambda作为它的默认值。

 fun <T> Collection<T>.joinToString(
            separator: String = ",",
            prefix: String = "",
            postfix: String = "",
            transform:(T)->String={it.toString()}
    ): String {
        val result = StringBuilder(prefix)
        for ((index, element) in this.withIndex()) {
            if (index > 0) result.append(separator)
            result.append(transform(element))
        }
        result.append(postfix)
        return result.toString()
    }

 val letteras= listOf<String>("Alpha","Beta")
 LogS(letteras.joinToString { it.toLowerCase() })//alpha,beta

注意这是一个泛型函数：它有一个类型参数T表示集合中元素的类型。lambda transform将接收这个类型的参数。

声明函数类型的默认值并不需要特殊的语法——只需要把lambda作为值放在=号后面。上面的例子展示了不同函数的调用方式：省略整个lambda，在括号以外传递lambda，或者以命名参数形式传递。

另一重选择声明一个参数可空的函数类型。注意这里不能直接调用作为参数传递进来的函数：kotlin会因为检测到潜在的空指针异常而导致编译失败。一种可选的方法是显示的检查null：

fun foo(callback:(()->Unit)?){
        if (callback!=null){
            callback()   
        }
    }

还有一个更简单的版本，它利用这样一个事实，函数类型是一个包含invoke方法的接口具体实现，作为一个普通方法，invoke可以通过安全调用语法被调用：callback?.invoke()。

   fun <T> Collection<T>.joinToString(
            separator: String = ",",
            prefix: String = "",
            postfix: String = "",
            transform:((T)->String)?={it.toString()}
    ): String {
        val result = StringBuilder(prefix)
        for ((index, element) in this.withIndex()) {
            if (index > 0) result.append(separator)
            var str=transform?.invoke(element)?:element.toString()
            result.append(str)
        }
        result.append(postfix)
        return result.toString()
    }

5.返回函数的函数

从函数中返回函数并没有函数作为参数传递那么常用，但它仍然非常有用。想象一下程序中的一段逻辑可能会因为程序的状态或其他条件产生变化——比如说，运输费用的计算依赖于选择的运输方式。可以定义一个函数来选择恰当的逻辑变体并将它作为另一个函数返回：

   enum class Delivery {STANDARD, EXPEDITED }

    class Order(val itemCount: Int)

    fun getShippingCostCalculator(
            delivery: Delivery
    ): (Order) -> Double {
        if (delivery == Delivery.EXPEDITED) {
            return { order -> 6 + 2.1 * order.itemCount }
        }
        return { order -> 1.2 * order.itemCount }
    }

      val calculator=getShippingCostCalculator(Delivery.EXPEDITED)
      LogS(calculator(Order(3)))//12.3

声明一个返回另一个函数的函数，需要指定一个函数类型作为返回类型。

在UI代码中定义一个返回函数的函数：

 data class Person(
            val firstName: String,
            val lastName: String,
            var phoneNumber: String?
    )

    class ContractListFilters {
        var prefix: String = ""
        var onlyWithPhoneNumber: Boolean = false

        fun getprediccate(): (Person) -> Boolean {
            val startsWithPrefix = {
                p: Person ->
                p.firstName.startsWith(prefix) || p.lastName.startsWith(prefix)
            }
            if (!onlyWithPhoneNumber) {
                return startsWithPrefix
            }
            return {
                startsWithPrefix(it)
                        && it.phoneNumber != null
            }
        }
    }

   val contacts = listOf(Person("Dmitry", "Jemerov", "123-4567"),
                Person("Svetlana", "Isakova", null))
        val contactListFilters=ContractListFilters()
        with(contactListFilters){
            prefix="Dm"
            onlyWithPhoneNumber=true
        }
        LogS(contacts.filter(
                contactListFilters.getprediccate()
        ))//[Person(firstName=Dmitry, lastName=Jemerov, phoneNumber=123-4567)]

getPredicate方法返回一个函数的值，这个值被传递给filter作为参数，Kotlin的函数类型可以让这一切变得很简单，就跟处理其他类型的值一样，比如字符串。

高阶函数是一个改进代码结构和减少重复代码的利器。

6.通过lambda去除重复代码

函数类型和lambda表达式一起组成了一个创建可重用代码的好工具。许多以前只能通过重复笨重的结构来避免的重复代码，现在可以通过使用简便的lambda表达式被消除。

定义站点访问技术：

    data class SiteVisit(
            val path: String,
            val duration: Double,
            val os: OS
    )

    enum class OS {WINDOWS, LINUX, MAC, IOS, ANDROID }

    val log=listOf(
            SiteVisit("/",34.0,OS.WINDOWS),
            SiteVisit("/",34.0,OS.MAC),
            SiteVisit("/",34.0,OS.WINDOWS),
            SiteVisit("/",34.0,OS.IOS),
            SiteVisit("/",34.0,OS.ANDROID)
    )

使用硬编码的过滤器分析站点访问数据

     val averageEindowsDuration=log
                .filter { it.os==OS.WINDOWS }
                .map(SiteVisit::duration)
                .average()

     LogS(averageEindowsDuration)//29.0

用一个普通方法去除重复代码

fun List<SiteVisit>.averafeDurarionFor(os: OS) = filter { it.os == os }.map(SiteVisit::duration).average()

LogS(log.averafeDurarionFor(OS.WINDOWS))//29.0

用一个复杂的硬编码函数分析站点访问数据

  val averageMobileDuration=log
                .filter { it.os in setOf(OS.IOS,OS.ANDROID) }
                .map(SiteVisit::duration)
                .average()

  LogS(averageEindowsDuration)//29.0

用一个高阶函数去除重复代码

 fun List<SiteVisit>.averageDurationFor(predicate:(SiteVisit)->Boolean)=
            filter(predicate).map(SiteVisit::duration).average()

LogS(log.averageDurationFor { it.os in setOf(OS.ANDROID,OS.IOS) })//29.0

函数类型可以帮助去除重复代码。如果你禁不住复制粘贴了一段代码，那么很可能这段代码是可以避免的，使用lambda，不仅可以抽取重复的数据，也可以抽取重复的行为。

spy_develop

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录