kotlin开发者大会部分总结

一.kotlin代码简化

中缀表达式
作用域函数注意各自使用场景，不要嵌套
扩展函数
比如px2dp

println(1f.dp())

比如扩展post

fun Activity?.Main(todo:() -> unit){
     Handler().post {
          todo()
     }
}

fun Activity?.Worker(todo:() -> unit){
     Thread {
          todo()
     }.start()
}

class MainActivity : AppCompatActivity(){
        ...
        Worker{
              Main{

              }
        }
}

java io的优化

BufferedReader bufferedReader = null;
        try {
            bufferedReader = new BufferedReader(new FileReader(new File("readme.md")));
        } catch (IOException ex){
            
        } finally {
            try {
                if(bufferedReader != null){
                   bufferedReader.close();
                }
            } catch (IOException ignore){

            }
        }

优化为
File("readme.md").readLines().foreach(::println)

泛型
在java中泛型是类型的代表，不是实体的代表，在kotlin中可以把泛型当作实体new出来
原理是因为inline关键字，在编译过程中，kotlin可以判断出这个泛型的实体是什么

reified修饰的泛型与java不兼容，必须用inline修饰

startActivity<MainActivity>()
inline fun <reified T:Activity> Activity?.startActivity(){
    this?.startActivity(Intent(this,T::class.java))
}

泛型

kotlin的协变与逆变

大前提 java不允许向下转型

协变只能出现在返回值中，逆变只能出现在方法的参数中，协变是out，逆变是in
比如现在有两个类，子类是苹果，父类是水果

class A<in T> 那么A<水果>是A<苹果>的子类
class A<out T> 那么A<苹果>就是A<水果>的子类

具体分为使用处与声明处

java	java示例	kotlin示例	kotlin
上界通配符	<? extends Number>	<out Number>	使用处协变
下界通配符	<? super Integer >	<in Int>	使用处逆变
无	无	interface Collection<out E>	声明处协变
无	无	interface Comparable<in T>	声明处逆变

集合操作的快捷

//只要有一个满足即成立
val resultAny = list.any {
   it / 2  == 1
}
//所有条件满足即成立
val resultAll = list.all{
     it > 0
}

DSL的风格实现，需要借助Anko库来实现

屏幕快照 2019-09-03 下午2.44.55.png
Sequence提升集合效率

var time = System.currentTimeMillis()
val list = (1..65535).toList().map {
      it * 2
}.filter {
      it % 3 == 0
}
list.first()
println(System.currentTimeMillis() - time)//29ms

var time = System.currentTimeMillis()
val sequence = (1..65535).asSequence().map {
      it * 2
}.filter {
      it % 3 == 0
}
sequence.first()
println(System.currentTimeMillis() - time)//7ms

internal关键字只允许在本module才能调用，不给外界调用
关于anko库

屏幕快照 2019-09-03 下午2.45.21.png

函数

kotlin可以将函数转换成一个值，变量，这个变量的类型就是函数

fun Int.sample(a:float,b:double) :Long = this * (a+b).toLong()
//变量 ：接收者 (参数) ->返回值 整个作为这个变量的函数类型 = 真正的函数赋值
val function:Int.(Float,Double) -> Long = Int::sample
//这个函数值一定要满足前边的函数类型
fun main() = sample(function)
//这个变量就可以作为参数传入别的函数中
fun sample(a:Int.(Float,Double) -> Long):Long = 3.a(1f,2.0)
//a是传入函数的变量名，可以直接使用a来调用这个函数

函数类型

open class Fruit
class Apple : Fruit()
open class Dog {
     open fun bark():String = "汪汪"
}

class Jinmao : Dog {
    open fun bark():String = "金毛汪汪"
}

fun parent(apple:Apple):Dog{
      println(apple)
      return Dog()
}

fun child(fruit:Fruit):Dog{
      println(fruit)
      return Jinmao()
}

var functionValue :  (Apple) -> Dog = ::parent
fun main(){
      val apple = Apple()
      var dog = functionValue(apple)
      dog.bark() //输出汪汪
      
      functionValue = ::child
      dog = functionValue(apple)
      dog.bark() //输出金毛汪汪
  
      // 编译报错，因为functionValue函数是(Apple) -> Dog类型
      // 即使被child赋值但是它的类型仍然是 (Apple) -> Dog
      val fruit = Fruit()
      functionValue(fruit)
}

那么child为什么可以对functionValue赋值成功

反编译代码会发现

 @NotNull
   private Function1 functionValue = (Function1)(new Function1((Test4)this) {
      // $FF: synthetic method
      // $FF: bridge method
      public Object invoke(Object var1) {
         return this.invoke((Test4.Apple)var1);
      }

      @NotNull
      public final Test4.Dog invoke(@NotNull Test4.Apple p1) {
         Intrinsics.checkParameterIsNotNull(p1, "p1");
         return ((Test4)this.receiver).parent(p1);
      }
      ...

这里用到了Function1接口，后边会详解讲这个接口，这里的in与out对应了前边的协变与逆变，这就是为什么调用不行，而赋值可以成功，因为函数调用在编译阶段是不会涉及到协变逆变的，只是检查调用类型

这里是in就是apple，out就是dog
所以可以理解为apple是fruit的父类，所以child可以赋值成功

public interface Function1<in P1, out R> : Function<R> {
    /** Invokes the function with the specified argument. */
    public operator fun invoke(p1: P1): R
}

lamda表达式实现原理

java的匿名内部类原理:匿名类在编译期间会生成新的.class文件
Java 8 的 lambda 表达式原理理:编译期不不产⽣生额外结果，在运⾏时会⽣成一个静态⽅法，将 lambda 表达式的代码保存在静态方法中，然后⽣成一个 SAM (就是只有一个方法的接口)接⼝的实现类，在该实现类中会调⽤用之前生成的静态⽅法。class 字节码调用指令使用的是 Java 7 新增的invokeDynamic（这个是一个新增的指令，调用运行时生成的函数，其它都是调用编译期就已经生成的函数，只有lamda使用）
kotlin目前lamda表达式实现原理也是匿名内部类，编译后会生成FunctionN接口的匿名类

屏幕快照 2019-09-04 下午12.22.13.png

两种实现的性能

匿名类:频繁使⽤匿名类会在编译期创建⼤量 class 文件，导致程序包变大，但运⾏时没有其它开销。
lambda:在编译期不会做额外⼯工作，即不会让程序包变大，但在运行时会动态生成代码，拖慢运⾏时的速度

二.性能

inline关键字

扩展函数，或者一些函数式参数建议用inline，其它函数不建议
因为虽然方法的出栈弹栈有性能消耗，但是很小，不是业务开发者需要考虑的问题，把所有的方法都inline到一个方法中显然是不合理，会造成一定的浪费
但是扩展函数，函数参数有一些lamda的实现是用匿名类实现的，会创建多余的对象，所以建议使用inline函数

//加inline关键字的方法，代码直接被编译到调用处
int times = 1000000
int index = 0
for (int i = times;index < i;index++){
     count  = index;
}
//未加inline关键字的方法,创建了lamda对象，然后调用原来的方法
Function lamda = new MyInlineKt$lamda();
noinlineRepeat(1000000,lamda)

inline的场景

优化高阶函数，扩展函数
支持泛型实例化

其它的一些性能注意

null safe 调用太多，实现原理就是判null

 dataBean?.data?.title1?.toInt()
//反编译
if (dataBean != null) {
         Data var10000 = dataBean.getData();
         if (var10000 != null) {
            String var4 = var10000.getTitle1();
            if (var4 != null) {
               String var2 = var4;
               boolean var3 = false;
               Integer.parseInt(var2);
            }
         }
      }

如果代码有10行，那么kotlin会对每行都判null
但在java中有时我们会写这样的代码，其实后边就都不会执行了

if (dataBean == null) {
    return;
}

foreach循环的性能问题，也是创建对象，但inline不会有问题
闭包函数，因为java匿名内部类中不能访问外部参数kotlin可以, 注意java可以访问成员变量，局部变量需要final
companion objects 等同于static final
在for循环中拼接也需要stringbuilder，+=这种写法会频繁创建stringbuilder
val 比 var 在编译期间可以确定值，性能好一点
by lazy 可以指定是否线程安全，默认不指定，会是线程安全，有开销，而且是double check的方式,如果没有线程安全问题可以传入(LazyThreadSafetyMode.NONE)作为参数
sequence优化
@JvmField 去掉默认get/set的实现

总结就是大部分一些kotlin有，java没有的特性，都会有一些实现成本，但不绝对

参考

https://kotlin.gdgbeijing.org/
https://www.jianshu.com/p/f1405bd19dea