kotlin习惯用法

• 创建POJO

data class Customer(val name: String, val email: String)

• 函数默认值

fun foo(a: Int = 0, b: String = "") {}

• lambda表达式

list.filter{ x -> x > 0}
list.filter{ it > 0 }

• 遍历map

for((k,v) in map){
    println("$k -> $v")
}

• infix 函数

infix fun Int.increase(size: Int): Int {
    return this + size
}

然后就可以通过类似1 increase 2来使用了

• 集合的只读创建

var list = listOf("a", "b", "c")
var map = mapOf("a" to 1, "b" to 2, "c" to 3)

这里还可以注意到to就是一个infix函数定义

• 懒加载

val p: String by lazy { "default" }

• 拓展函数

fun String.newFunc(): String {
    return this + "new"
}

然后就可以通过"world ".newFunc()将函数当做类的内置函数来用

• 创建单例(?)

object Resource {
    val name = "lhyz"
}

可以这样创建val res = Resource

• 简化空检查

fun checkSize(arg: String?): Int {
    return arg?.length ?: -1
}

fun checkSize(arg: String?): Int {
    arg?.let {
        return arg.length
    }
    return 0
}

• 返回when语句

fun transColor(color: String): Int {
    return when (color) {
        "R" -> 0
        "G" -> 1
        "B" -> 2
        else -> throw IllegalAccessException()
    }
}

• try/catch 表达式

    val result = try {
        1
    } catch (e: ArithmeticException) {
        2
    }

同理还有if表达式也有此类表达

val result = if (true){
        "one"
    }else{
        "two"
    }

• 使用with针对同一对象实例调用多个方法

class Turtle {
    fun penDown() {}
    fun penUp() {}
    fun turn(degrees: Double) {}
    fun forward(pixels: Double) {}
}

    val myTurtle = Turtle()
    with(myTurtle) {
        //draw a 100 pix square
        penDown()
        for (i in 1..4) {
            forward(100.0)
            turn(90.0)
        }
        penUp()
    }

• 使用Java 7的try with resources类似方法

    val stream = Files.newInputStream(Paths.get("path/to/file"))
    stream.buffered().reader().use {
        reader ->
        print(reader.readText())
    }

use用法就是自动关闭的用法
可以看出use函数的定义是inline fun

public inline fun <T : Closeable?, R> T.use(block: (T) -> R): R {
    var closed = false
    try {
        return block(this)
    } catch (e: Exception) {
        closed = true
        try {
            this?.close()
        } catch (closeException: Exception) {
        }
        throw e
    } finally {
        if (!closed) {
            this?.close()
        }
    }
}

• 泛型函数的简化用法(?)

inline fun <reified T: Any> Gson.fromJson(json): T = this.fromJson(json, T::class.java)

总结

目前来看，特别有趣的特性主要有拓展函数，infix，inline三种函数以及lambda表达式

*不熟悉的用法使用？标记