kotlin不容忽视的小细节

kotlin支持扩展函数

Kotlin的扩展函数可以让你作为一个类成员进行调用的函数，但是是定义在这个类的外部。这样可以很方便的扩展一个已经存在的类，为它添加额外的方法。

rxjava线程切换：

fun <T> Observable<T>.setThread(): Observable<T> {
    return subscribeOn(Schedulers.io())
         .observeOn(AndroidSchedulers.mainThread())
}

findViewById：

fun <V : View> Activity.bindView(id: Int): Lazy<V> {
    return lazy { findViewById<V>(id) }
}

更加通用的自定义表达式：

fun <T> T.checkExpression(expression: Boolean, function: T.() -> T): T {
    if (expression) {
        function.invoke(this)
    }
    return this
}

还可以定义些通用函数

/**
 * int px转dp
 */
fun Int.toDp(): Int{
    val scale = App.context.resources.displayMetrics.density
    return (this * scale + 0.5f).toInt()
}




/**
 * float px转dp
 */
fun Float.toDp(): Float{
    val scale = App.context.resources.displayMetrics.density
    return this * scale + 0.5f
}




/**
 * List<T>转Map<K,T>，获取对数据
 */
inline fun <K,T> Iterable<T>.toMap(transform: (T) -> K): MutableMap<K, T>{
    val map = mutableMapOf<K, T>()
    forEach {
        map[transform.invoke(it)] = it
    }
    return map
}




/**
 * List<T>转List<R>
 */
inline fun <T, R> Iterable<T>.convert(transform: (T) -> R): Iterable<R>{
    val list = mutableListOf<R>()
    forEach {
        list.add(transform.invoke(it))
    }
    return list
}

协程

类似于线程，但是占用内存更低且更高效，同时在协程中执行代码，是顺序执行，而java 线程需要通过回调。

// do first: main
    // do async: DefaultDispatcher-worker-5
    // do end: main
    GlobalScope.launch(Dispatchers.Main) {
        println("do first: ${Thread.currentThread().name}")
        GlobalScope.async(Dispatchers.Default) {
            println("do async: ${Thread.currentThread().name}")
        }.await()
        println("do end: ${Thread.currentThread().name}")
    }

kotlin的lambda表达式规则

不用lambda表达式：

// 这里举例一个Android中最常见的按钮点击事件的例子
mBtn.setOnClickListener(object : View.OnClickListener{
        override fun onClick(v: View?) {
            Toast.makeText(this,"onClick",Toast.LENGTH_SHORT).show()
        }
    })

等价于：

// 调用
mBtn.setOnClickListener { v -> Toast.makeText(this,"onClick",Toast.LENGTH_SHORT).show() }

特性如下：

• 表达式总是被大括号括着

• 其参数(如果存在)在 -> 之前声明(参数类型可以省略)

• 函数体(如果存在)在 -> 后面

相比java8的lambda表达式，还有其他特性：

当方法中最后一个参数为函数类型，则可以放在大括号调用

fun lambdaFun(boolean: Boolean, block: (Int) -> Unit){
  
}


fun lambdaFunTest(){
    lambdaFun(true, block = {
        
    })
    
    lambdaFun(true){
        
    }


}

it

it是在当一个高阶函数中Lambda表达式的参数只有一个的时候可以使用it来使用此参数。it可表示为单个参数的隐式名称，是Kotlin语言约定的。

val arr = arrayOf(1,3,5,7,9)
// 过滤掉数组中元素小于2的元素，取其第一个打印。这里的it就表示每一个元素。
println(arr.filter { it < 5 })