这周在部门进行了一场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对空指针的处理的方式有以下：
if判断，过滤null，缺陷：代码冗余
做一层包装，比如Java世界里，Double，Int 装箱；Java8里Optional包装; 缺陷：代码冗余，额外的包装接口影响运行时性能，即使在代码中到处都使用了Optional，仍然需要处理JDK、Android框架，以及其他第三方库中的方法返回null值。
使用注解（@nullable，@NotNull） + 插件代码检测；缺陷：这些工具不是标准Java编译过程的一部分，很难保证她们自始至终都被应用，而且很难使用注解标记覆盖所有可能发生错误的地方
Kotlin要怎么做的？
Kotlin世界里
以字符串对象为例
在Java里：
String = String + null
在Kotlin里
String = String
String？= String + null
因此，String和String？是两种类型。Kotlin中的String？相当于Java里的String
对类型，Kotlin让我们有了新的认识：
- Kotlin中，所有常见类型默认都是非空的。
- 什么是类型？就是对数据的分类，分类的类目里有一类是null
隆重登场, Kotlin的处理
程序执行顺序上出了偏差或是其他原因，对象引用没有就建立起来，就会出现空指针，空指针在逻辑上就存在了
- ?.调用 把一次null检查和一次方法调用合并成一个操作。
- ?: Evlis运算符：问号前面的对象是null么？如果是则返回冒号后面的值，如果不是则返回问号前的值
- 拓展函数
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表达式存在三个简化约定：
- 如果lambda表达式，参数类型为空，可以省略参数和箭头
- 如果lambda表达式参数类型只有一个，可以省略参数和箭头并使用it作为形参
- 如果lambda表达式作为函数的最后一个参数，可以把放到括号外
来一段代码实例
现在有一个需求：添加前缀，分隔符，后缀，打印出某个给定的集合里的所有元素
java实现：
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实现：
@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()
}
对上述代码作简化，如下
@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()
}
使用拓展函数，减少一个入参
fun <T> Collection<T>.separateInto(prefix: String = "(",
separator: String = ",",
postfix: String = ")"
): String {
return separate3(this, prefix, separator, postfix)
}
Kotlin中闭包的实现
一个简易的方法调用次数计数器：
fun compute(): () ->Int{
var count = 0
fun inner(): Int{
count ++
return count
}
return {inner()}
}
调用
val message:() -> Int = compute()
for(i in 0..3){
println(message())
}
输出结果
1234
此时，compute()方法里的count像全局变量，累加记数。简易的访问流程：外部的A访问B函数，B内部的函数C访问B，同时B返回C。
闭包就是这样一种结构：函数嵌套一个访问自己变量的内部函数结构
闭包带给我们两个好处：
- 让某个变量保存在内存里，能起到消除不与其他方法通信的成员变量的作用
- 外部能访问到函数内部的变量
相关链接
Kotlin学习相关链接：
