一.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/
//www.greatytc.com/p/f1405bd19dea
