Kotlin基础（一）

基本语法

定义包

package my.demo

import java.util.*

// ……

目录与包的结构无需匹配：源代码可以在文件系统的任意位置。

定义函数

带有两个 Int 参数、返回 Int 的函数：

fun sum(a:Int,b:Int):Int{
	return a+b;
}

将表达式作为函数体、返回值类型自动推断的函数：

fun sum(a:Int,b:Int) = a+b;

函数返回无意义的值：

fun printSum(a:Int,b:Int):Unit{
	println("sum of $a and $b is ${a + b}")
}

Unit 返回类型可以省略：

fun printSum(a:Int,b:Int){
	println("sum of $a and $b is ${a + b}")
}

定义变量

定义只读局部变量使用关键字 val 定义。只能为其赋值一次。

val a:Int = 1 // 立即赋值
val b = 2 //自动推断出 `Int` 类型
val c:Int //如果没有初始值类型不能省略
c = 3 //明确赋值

可重新赋值的变量使用 var 关键字：

var x = 5 // 自动推断出 `Int` 类型
x += 1

顶层变量：

val PI = 3.14
var x = 0
fun incrementX() {
	x += 1
}

注释

正如 Java 与 JavaScript，Kotlin 支持行注释及块注释。

// 这是一个行注释

/* 这是一个多行的
   块注释。 */

与 Java 不同的是，Kotlin 的块注释可以嵌套。

使用字符串模板

fun maxOf(a:Int,b:Int):Int{
	if(a > b){
		return a
	}else{
		return b
	}
}

使用 if 作为表达式:

fun maxOf(a:Int,b:Int) = if(a > b) a else b

使用可空值及 null 检测

当某个变量的值可以为 null 的时候，必须在声明处的类型后添加 ? 来标识该引用可为空。
如果 str 的内容不是数字返回 null：

fun parseInt(str: String): Int?{
	//......
}

使用返回可空值的函数:

fun printProduct(arg1:String,arg2:String){
	val x = parseInt(arg1)
	val y = parseInt(arg2)
	// 直接使用 `x * y` 会导致编译错误，因为他们可能为 null
	if (x != null && y != null) {
        // 在空检测后，x 与 y 会自动转换为非空值（non-nullable）
        println(x * y)
    }
    else {
        println("either '$arg1' or '$arg2' is not a number")
    }    
}

或者

// ……
if (x == null) {
    println("Wrong number format in arg1: '$arg1'")
    return
}
if (y == null) {
    println("Wrong number format in arg2: '$arg2'")
    return
}

// 在空检测后，x 与 y 会自动转换为非空值
println(x * y)

使用类型检测及自动类型转换

is 运算符检测一个表达式是否某类型的一个实例。 如果一个不可变的局部变量或属性已经判断出为某类型，那么检测后的分支中可以直接当作该类型使用，无需显式转换：

fun getStringLength(obj:Any):Int?{
	if(obj is String){
		// `obj` 在该条件分支内自动转换成 `String`
		return obj.length
	}
	//在离开类型检测分支后，`obj` 仍然是 `Any` 类型
	return null
}

或者

fun getStringLength(obj: Any):Int?{
	if(obj !is String) return null
	// `obj` 在这一分支自动转换为 `String`
    return obj.length
}

甚至

fun getStringLength(obj:Any):Int?{
 // `obj` 在 `&&` 右边自动转换成 `String` 类型
 if(obj is String && obj.length>0){
 	return obj.length
 }
 return null
}

使用 for 循环

val items = listOf("apple", "banana", "kiwifruit")
for(item in items){
	println(item)
}

或者

val items = listOf("apple", "banana", "kiwifruit")
for (index in items.indices){
	println("item at $index is ${items{index}}")
}

使用 while 循环

val items = listOf("apple", "banana", "kiwifruit")
var index = 0
while(index < items.size){
	println("item at $idnex is ${items[index]}")
	index ++
}

使用 when 表达式

fun describe(obj: Any):String = 
	when(obj){
		1 -> "One"
		"Hello" -> "Greeting"
		is Long -> "Long"
		!is String -> "Not a String"
		else -> "Unknown"
	}

使用区间(range)

使用 in 运算符来检测某个数字是否在指定区间内：

val x = 10
val y = 9
if(x in 1..y+1){
	println("fits in range")
}

检测某个数字是否在指定区间外:

val list = listOf("a","b","c")
if(-1 !in 0..list.lastIndex){
	println("-1 is out of range")
}
if(list.size !in list.indices){
	println("list size is out of valid list indices range,too")
}

区间迭代:

for(x in 1..5){
	print(x)
}

或数列迭代：

for(x in 1..10 step 2){
	print(x)
}
println()
for(x in 9 downTo 0 step 3){
	print(x)
}

使用集合

对集合进行迭代:

for(item in items){
	println(item)
}

使用in运算符来判断集合内是否包含实例：

when{
	"orange" in items -> println("juicy")
	"apple" in items -> println("apple is fine too")
}

使用 lambda 表达式来过滤（filter）与映射（map）集合：

val fruits = listOf("banana", "avocado", "apple", "kiwifruit")
fruits
	.filter{ it.startsWith("a")}
	.sortedBy{it}
	.map{it.toUpperCase()}
	.forEach{println(it)}

创建基本类及其实例：

val rectangle = Rectangle(5.0,2.0)// 不需要“new”关键字
val triangle = Triangle(3.0,4.0,5.0)

习惯用法

创建 DTOs（POJOs/POCOs）

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

会为Customer类提供以下功能:

• 所有属性的 getters （对于 var 定义的还有 setters）
• equals()
• hashCode()
• toString()
• copy()
• 所有属性的component1()、component2()…等等

函数的默认参数

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

过滤list

val positives = list.filter{x-> x > 0}

或者可以更短

val positives = list.filter{it > 0}

字符串内插

println("Name $name")

类型判断

when(x){
	is Foo //-> ...
	is Bar //->...
	else //-> ...
}

map/pair型list

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

k、v可以改成任意名字。

使用区间

for(i in 1..100){...}  //闭区间：包含100
for(i in 1 until 100){...} //半开区间：不包含100
for(x in 2..10 step 2){...} 
for(x in 10 downTo 1){}
if(x in 1..10){...} 

只读list

val list = listOf("a","b","c")

只读map

val map = mapOf("a" to 1,"b" to 2,"c" to 3)

访问map

printlv(map["key"])
map["key"] = value

延迟属性

val p :String by lazy{
	//计算该字符串
}

扩展函数

fun String.spaceToCamelCase(){...}
"Convert this to camelcase".spaceToCamelCase()

创建单例

object Resource{
	val name = "Name"	
}

If not null 缩写

val files = File("Test").listFiles()
println(files?.size)

if not null and else 缩写

val files = File("Test").listFiles()
println(files?.size?:"empty")

if null 执行一个语句

val values = ...
val email = values["email"]?:throw IllegalStateException("Email is missing!")

在可能会空的集合中取第一元素

val values = ...
val mainEmaol = emails.firstOrNull()?:""

if not null 执行代码

val value = ...
value?.let{
	...//代码会执行到此处, 假如data不为null
}

映射可空值（如果非空的话）

val value = ...
val mapped = value?.let{transformValue(it)}?:defaultValueIfValueIsNull

返回when表达式

fun transform(color:String):Int{
	return when(color){
		"Red" -> 0
		"Green" -> 1
		"Blue" -> 2
		else -> throw IllegalArgumentException("Invalid color param value")
	}
}

“try/catch”表达式

fun test(){
	val result = try{
		count()
	}catch(e: ArithmeticException){
		throw IllegalStateException(e)
	}
	// 使用 result
}

“if”表达式

fun foo(param: Int){
	val result = if(param == 1){
		"one"
	}else if(param == 2){
		"two"
	}else{
		"three"
	}
}

返回类型为 Unit 的方法的 Builder 风格用法

fun arrayOfMinusOnes(size: Int): IntArray{
	return IntArray(size).apply{fill(-1)}
}

单表达式函数

fun theAnswer() = 42

等价于

fun theAnswer(): Int{
	return 42
}

单表达式函数与其它惯用法一起使用能简化代码，例如和 when 表达式一起使用：

fun transform(color:String):Int = when (color){
	"Red" -> 0
	"Green" -> 1
	"Blue" -> 2
	else -> throw IllegalArgumentException("Invalid color param value")
}

对一个对象实例调用多个方法 （with）

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

val myTurtle = Turtle()
with(myTurtle) { // 画一个 100 像素的正方形
    penDown()
    for(i in 1..4) {
        forward(100.0)
        turn(90.0)
    }
    penUp()
}

Java 7 的 try with resources

val stream = Files.newInputStream(Paths.get("/some/file.txt"))
stream.buffered.reader().use{reader->
	println(reader.readText())
}

对于需要泛型信息的泛型函数的适宜形式

//  public final class Gson {
//     ……
//     public <T> T fromJson(JsonElement json, Class<T> classOfT) throws JsonSyntaxException {
//     ……
inline fun<reified T:Any> Gson.fromJson(json: JsonElement):T = this.fromJson(json,T::class.java)

使用可空布尔

val b:Boolean?= ...
if(b == true){
	...
}else {
	//`b`是false或者null
}

交换两个变量

var a= 1
var b = 2
a = b.also{b = a}

摘自 https://www.kotlincn.net/