网创优客建站品牌官网
为成都网站建设公司企业提供高品质网站建设
热线:028-86922220
成都专业网站建设公司

定制建站费用3500元

符合中小企业对网站设计、功能常规化式的企业展示型网站建设

成都品牌网站建设

品牌网站建设费用6000元

本套餐主要针对企业品牌型网站、中高端设计、前端互动体验...

成都商城网站建设

商城网站建设费用8000元

商城网站建设因基本功能的需求不同费用上面也有很大的差别...

成都微信网站建设

手机微信网站建站3000元

手机微信网站开发、微信官网、微信商城网站...

建站知识

当前位置:首页 > 建站知识

Kotlin快速入坑指南(干货型文档)-创新互联

前言

创新互联建站拥有网站维护技术和项目管理团队,建立的售前、实施和售后服务体系,为客户提供定制化的成都网站制作、成都网站建设、网站维护、南充服务器托管解决方案。为客户网站安全和日常运维提供整体管家式外包优质服务。我们的网站维护服务覆盖集团企业、上市公司、外企网站、商城网站开发、政府网站等各类型客户群体,为全球千余家企业提供全方位网站维护、服务器维护解决方案。

即使每天10点下班,其实需求很多,我也要用这腐朽的声带喊出:我要学习,我要写文章!!

又是一篇Kotlin的文章,为啥...还不是因为工作需要。毫无疑问,最好的学习方式是通过官方文档去学习。不过个人觉得官方文档多多少少有一些不够高效。

中文官方文档

因此这篇是从我学习的个人视角以文档的形式去输出Kotlin语言基础的学习。
不扯淡了,开整。

正文

1、高阶函数

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

个人为什么把这个语言特性放在第一位,因为我觉得这是我们Java语言中所不支持的。然而这个特性基本贯穿整个Kotlin语言体系。所以个人把它放到了第一位,也希望各位小伙伴能够重视这个小小的特性。先看看一个小小的demo,感受一下这个特别特性:

// 函数定义
fun funtion(num: Int, innerFun: (Int) -> Int): Int {
    return innerFun(num)
}

简单解释一下上边的代码。我们先看函数定义,这里定义了一个名为funtion并且返回值为Int的函数,此外这个函数接受一个Int参数和一个函数类型的参数(这个函数需要传递一个Int参数,并且返回一个Int值)。
接下来我们调用一下:

// 函数调用
val result = funtion(1) {
    it + 666
}

对于Lambda来说,入参如果是一个的话可以用it来表示

说实话,第一次我看到这种调用的时候,是一脸懵逼的。不知道刚入坑的小伙伴是不是和我一样的感受?因为这种写法包含小tips:
我们的innerFun是可以被简化为一个Lambda,而当Lambda作为函数的最后一个参数时,是可以将其写在函数之外的。也就是Demo中的funtion(1){}。

此外我们要注意一点,这里我们的函数实例,并没有return,这是因为。lambda 表达式中的最后一个表达式是返回值
实际上这就是相当于调用了funtion方法的俩个参数,咱们换一种传统的写法,二者是等价的:

val inner = fun(num: Int): Int {
return num + 1
}
val result = funtion(1, inner)

OK,接下来咱们趁热打铁,再感受感受函数操作的“骚操作”。接下来我们看一看其实情况下的用法:

// 函数定义1
fun funtion(num: Int, innerFun: (Int, Int) -> Int): Int {
return innerFun(num, num + 1)
}
// 函数调用1(上文提到,入参为1个可以用it表示,那么俩个或者多个呢?我们可以如下,自定义)
val result = funtion(1) { num1, num2 ->
num1 + num2 + 666
}
// 函数调用2(除了Lambda的调用方式,我们还可以用匿名函数,二者是一样的)
val result = funtion(1, fun(num1: Int, num2: Int): Int {
return num1 + num2 + 666
}

OK,关于高阶函数的内容,就聊这么多,因为有了这个其实,很多内容也就很好上手了。接下来就让我们一同看看基于高阶函数的内置封装。

2、操作符

集合操作符

个人觉得,Kotlin操作符中。开发中颇为常用的是集合操作符,比如我们有时需要对一些数据进行连续的转化,我们可能会使用RxJava;

Observable.create(new ObservableOnSubscribe>() {
            @Override
            public void subscribe(ObservableEmitter> e) throws Exception {
                // 省略构建List
                e.onNext(data);
            }
        }).flatMap(new Function, ObservableSource>() {
            @Override
            public ObservableSource apply(List customModels) throws Exception {
                return Observable.fromIterable(customModels);
            }
        }).map(new Function() {
            @Override
            public String apply(CustomModel customModel) throws Exception {
                return customModel.name;
            }
        }).subscribe(new Consumer() {
            @Override
            public void accept(String s) throws Exception {
                // 操作s
            }
        });

这里简单,写了一个RxJava的Demo:我们有一个List集合,先把它一个个发送,然后把每一个数据转成String,最后去String进行处理。
而在Kotlin中,应对上述的需求,我们该怎么做?由于操作符的支持,我们可以极为方便的进行这类操作:

val data = arrayListOf(// ...省略构建的过程)
val newData=data.map {
    it.name
}.forEach {
    // 操作it
}

用法很简单,乍一看很唬人。但是其实很简单,回忆一下我们再开篇奠定的高阶函数的基础。这里其实就是调用了data的扩展函数map(拓展函数是一种语法,可以拓展现有的类。比如这个map就是拓展了Iterable,下文我们会展开它的实现)。对它进行类型转变,然后进而调用forEach自动对这个集合进行遍历。

接下来让我们点进去,看一看具体的实现:

// 注意看,这里map的**返回值**,是一个List,也就是说最终将返回map后的类型集合。因此我们可以继续进行链式调用。
public inline fun  Iterable.map(transform: (T) -> R): List {
    return mapTo(ArrayList(collectionSizeOrDefault(10)), transform)
}

public inline fun > Iterable.mapTo(destination: C, transform: (T) -> R): C {
    for (item in this)
        destination.add(transform(item))
    return destination
}

说白了,这里的集合操作符就是把转化的实现通过参数的形式暴露出来,由我们自行去处理,其他的事情,有内部封装去做。
当然,这其中还有很多有趣的操作符,各位小伙伴可以自行去了解。不过原理都是大同小异~

3、作用域函数

上述我们聊的是作用在集合上的操作符,说白了。它们就是拓展在对应集合类上的函数而已。那么可能有小伙伴会问,有没有作用在对象上的?没错,是有的。也就是我们接下来要聊的:作用域函数

其实很常见:

"Kotlin".let{
    it.toInt()
}
"Kotlin".run{
    this.toInt()
}

"Kotlin".apply{
}
"Kotlin".also{
}

public inline fun  T.let(block: (T) -> R): R
public inline fun  T.run(block: T.() -> R): R

public inline fun  T.apply(block: T.() -> kotlin.Unit): T
public inline fun  T.also(block: (T) -> kotlin.Unit): T

咱们看一下,它们哥四个的定义,其实很清晰。这里以返回值的类型,俩俩分类:

  • let/run。这俩个函数都可以返回另一种类型;不同在于let有入参,而run没有。
  • also/apply。 这俩个函数返回值都是本身,其中apply没有入参,而also有。

    不过即使没有入参,也可以通过this,得到本身。

上述函数的作用还是挺方便的,比如:

Model model ;
// ...省略初始化过程
if(model!=null){
    // 省略大段的操作逻辑
}

这种写法,在kotlin中可以这么写:

model?.alse{
    // 省略大段的操作逻辑
}
// 有需求我们可以继续调用它的作用域函数

如果你还有一些else操作,那么没辙了,kotlin中也只能老老实实if-else

当然,还有一些有趣的作用域函数,比如在Java中:

boolean isTure;
// 省略boolean判断逻辑
if(isTure){
    // 省略大段的操作逻辑
}

到Kotlin中可以这样来搞:

某对象.takeIf{
    // boolean判断逻辑
}?.{
    // 省略大段的操作逻辑
}
// 有需求我们可以继续调用它的作用域函数

takeIf:会根据入参的函数的返回值(true/false),决定自己(takeIf)的返回值是null还是调用者。如果是false,那么就会返回null,因此这里使用?的方式继续去调用后续操作。
我个人比较喜欢作用域函数, 因为可以省略很多if。接下来我们来换个稍稍复杂的逻辑:已知一个方法,入参是一个Model,我们要判断当这个Model对象的age属性大于10,打印这个Model对象的名字。
对于Java来说,我们可能这么写:

public void fun(Model model) {
    // 写了3个if。
    if (model != null) {
        if (model.age>10){
            if (model.name!=null){
                // 打印model.name
            }
        }
    }
}

class Model {
    String name;
    int age;
}

对于Kotlin来说,我们可以这么写:

fun funtion(model : Model){
    model?.takeIf{
        it.age > 10
    }?.let{
        // 打印it.name
    }
}

是不是简洁了很多?但是单说简洁这种东西,似乎并没有什么卵用...不过写起来,真的很爽!不信,大家可以试试~~

尾声

这篇文章,想聊的内容就这么多。个人认为其实理解了高阶函数,(PS:不知道为啥起了个名叫高阶函数,整得好像很高级似的。)Kotlin就可以很快的上手,并且能感受到Kotlin写起来的爽快之处~
这里的确有些安利的意味。那是因为自己最开始对新技术其实接受度并不高,总认为新东西有各种各样的问题...当自己去了头条之后,才发现身边的同事那种高昂的学习劲头,(Kotlin?对他们来说不叫新东西...Jatpack,Flutter都已经在线上项目中跑了)自己还有什么理由说:求求别更新了,我学不动了...
还是那句话:干就完了!

另外有需要云服务器可以了解下创新互联scvps.cn,海内外云服务器15元起步,三天无理由+7*72小时售后在线,公司持有idc许可证,提供“云服务器、裸金属服务器、高防服务器、香港服务器、美国服务器、虚拟主机、免备案服务器”等云主机租用服务以及企业上云的综合解决方案,具有“安全稳定、简单易用、服务可用性高、性价比高”等特点与优势,专为企业上云打造定制,能够满足用户丰富、多元化的应用场景需求。


分享题目:Kotlin快速入坑指南(干货型文档)-创新互联
文章分享:http://bjjierui.cn/article/ggijc.html

其他资讯