开启Kotlin编程之旅&Java程序员的思维进化

这周在部门进行了一场Kotlin分享,于是把分享内容整理出这篇文章

Kotlin编程语言简介

  • 由Intelij IDEA生产商JetBrains开源
  • 2011年开始,2016年初发布1.0正式版,目前最新1.2.31
  • 基于JVM平台,JS平台和Native的编程语言
  • 静态的,支持函数式编程范式
  • 与Java语言极高的兼容和互操作

Kotlin的生态环境

  • GitHub star 2万多
  • Kotlin在2018 TIOBE 3月份语言排行榜38名
  • 国外Stackoverflow 发布的2018 Developer Survey Results报告中,75.1%对Kotlin感兴趣
  • Spring 5.0版本将支持Kotlin
  • Kotlin不足:编译器存在优化空间,大范围使用目前只在Android开发领域

Kotlin的语言特性&Kotlin与Java的差异

空指针安全

引用/对象为空时调用报NullPointException异常

Java世界里

Java对空指针的处理的方式有以下:

  1. if判断,过滤null,缺陷:代码冗余

  2. 做一层包装,比如Java世界里,Double,Int 装箱;Java8里Optional包装; 缺陷:代码冗余,额外的包装接口影响运行时性能,即使在代码中到处都使用了Optional,仍然需要处理JDK、Android框架,以及其他第三方库中的方法返回null值。

  3. 使用注解(@nullable,@NotNull) + 插件代码检测;缺陷:这些工具不是标准Java编译过程的一部分,很难保证她们自始至终都被应用,而且很难使用注解标记覆盖所有可能发生错误的地方

Kotlin要怎么做的?

Kotlin世界里

以字符串对象为例

在Java里:

1
String = String + null

在Kotlin里

1
2
String = String  
String?= String + null

因此,String和String?是两种类型。Kotlin中的String?相当于Java里的String

对类型,Kotlin让我们有了新的认识:

  1. Kotlin中,所有常见类型默认都是非空的。
  2. 什么是类型?就是对数据的分类,分类的类目里有一类是null

隆重登场, Kotlin的处理

程序执行顺序上出了偏差或是其他原因,对象引用没有就建立起来,就会出现空指针,空指针在逻辑上就存在了

  1. ?.调用 把一次null检查和一次方法调用合并成一个操作。
  2. ?: Evlis运算符:问号前面的对象是null么?如果是则返回冒号后面的值,如果不是则返回问号前的值
  3. 拓展函数
1
2
3
4
5
6
7
8
9
10
11
12
13
data class Person(val name: String, val age: Int){

fun walk(){
println("$name is walking")
}
}

val p = Person("Kotlin",6)
val p2 = null
p2?.walk()

val p3 = p2?:p
println("${p3.name}")

简洁、高效性

  • 好吃的语法糖,少了Java冗余啰嗦;比如类型推断与自动强转,引入数据类data
  • 语言层级提供了大量的非常方便的实现;比如Kotlin的标准库封装了大量对集合操作的快捷方法
  • 命名参数,默认参数
  • 拓展函数
  • 高阶函数,局部函数实现闭包

kotlin提供了一些特性保证Kotlin简洁高效,比如:

拓展函数

StringUtil.captitalize(s)
s.captitalize

意义:一方面让代码组织的更简洁,另一方面暗合了Java6大设计原则的开闭原则。对原来的类的定义不做修改,而是通过拓展特性来完成(java实现上是通过工具类组合的方式来做的)

运算符重载

set.add(2)
set += 1

中缀调用

1.to("one")
1 to one

get方法约定

当作成员变量般调用

map.get("key")
map["key"]

invoke约定/对()操作符的重载

有了这个约定,在Kotlin的世界里,一切对象都可以认为是函数了。比如lambda表达式,可以这样使用labmda()就是因为
Kotlin约定了,除非是内联,lambda表达式都会被编译成实现了函数式接口(Function1)的类,这些接口定义了具有对应数量参数的invoke方法

比Java8更接近的函数式/声明式范式

Lambda表达式存在三个简化约定:

  1. 如果lambda表达式,参数类型为空,可以省略参数和箭头
  2. 如果lambda表达式参数类型只有一个,可以省略参数和箭头并使用it作为形参
  3. 如果lambda表达式作为函数的最后一个参数,可以把放到括号外

来一段代码实例

现在有一个需求:添加前缀,分隔符,后缀,打印出某个给定的集合里的所有元素

java实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class SeparatorUtils {

/**
*
* @param collections 集合
* @param prefix 前缀
* @param separator 分隔符
* @param postfix 后缀
* @param <T> 集合泛型
* @return 分隔后的结果
*/
@NotNull
public static <T> String separate(Collection<T> collections, String prefix , String separator, String postfix) {
Objects.requireNonNull(collections);
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append(prefix);
int index = 0;
for (T t : collections) {
if(index > 0){
stringBuilder.append(separator);
}
stringBuilder.append(t.toString());
index ++;
}
stringBuilder.append(postfix);
return stringBuilder.toString();
}
}

对应Kotlin实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@JvmOverloads
public fun <T> separate(
collection: Collection<T>,
prefix: String = "(",
separator: String = ",",
postfix: String = ")"
): String {
val stringBuilder = StringBuffer(prefix)
for ((index, element) in collection.withIndex()) {
if (index > 0) {
stringBuilder.append(separator)
}
stringBuilder.append(element)
}
stringBuilder.append(postfix)
return stringBuilder.toString()
}

对上述代码作简化,如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@JvmOverloads
fun <T> separate3(
collection: Collection<T>,
prefix: String = "(",
separator: String = ",",
postfix: String = ")"
): String {
return StringBuffer(prefix)
.apply {
for ((index, element) in collection.withIndex()) {
if (index > 0) {
append(separator)
}
append(element)
}
append(postfix)
}.toString()
}

使用拓展函数,减少一个入参

1
2
3
4
5
6
fun <T> Collection<T>.separateInto(prefix: String = "(",
separator: String = ",",
postfix: String = ")"
): String {
return separate3(this, prefix, separator, postfix)
}

Kotlin中闭包的实现

一个简易的方法调用次数计数器:

1
2
3
4
5
6
7
8
fun compute(): () ->Int{
var count = 0
fun inner(): Int{
count ++
return count
}
return {inner()}
}

调用

1
2
3
4
val message:() -> Int = compute()
for(i in 0..3){
println(message())
}

输出结果

1
1234

此时,compute()方法里的count像全局变量,累加记数。简易的访问流程:外部的A访问B函数,B内部的函数C访问B,同时B返回C。

闭包就是这样一种结构:函数嵌套一个访问自己变量的内部函数结构

闭包带给我们两个好处:

  1. 让某个变量保存在内存里,能起到消除不与其他方法通信的成员变量的作用
  2. 外部能访问到函数内部的变量

相关链接

Kotlin学习资源: