【Kotlin】从Java转向Kotlin，耐心看完这篇博客就够了。Kotlin快速入门教程分享

本文链接：https://blog.csdn.net/a4019069/article/details/126814446

导读

适合群体：Java已经入门的人，如果是零基础，不要勉强！虽然没有深奥的术语，即使有也尽可能通俗易懂。

Kotlin和Java都是Jvm语言，相同的部分能省则省（篇幅有限），重点是Kotlin。

示例代码的注释很重要。最好可以使用IDEA等开发工具运行一下。

最后创作不易，全部都是自己亲手码出来的5万多字的笔记分享，如果觉得对您学习Kotlin有帮助，还请三连（点赞，关注，打赏），这是我的创作动力。

build.gradle.kts

//version_gradle:7.4.2
//version_jdk:17.0.6
plugins {
    kotlin("jvm") version "1.8.0"
    application
}

repositories {
    mavenLocal()
    mavenCentral()
}

dependencies {
    testImplementation(kotlin("test"))
    implementation("org.jetbrains.kotlin:kotlin-reflect:${kotlin.coreLibrariesVersion}")
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4")
}

tasks.test {
    useJUnitPlatform()
}

tasks.withType<JavaCompile> {
    options.encoding = "UTF-8"
}

kotlin {
    jvmToolchain(17)
}

application {
    mainClass.set("MainKt")
}

基础篇

启动入口

main

fun main(args: Array<String>) {
	println("Hello World")
}

无参数的main方法与有参数传入的main方法都是kotlin程序启动的入口方法。
启动时先调用有参的main方法，然后调用无参的main方法。

fun main() {
	println("Hello World")
}

虽然两个main方法可以同时存在，无形参的main方法不会执行。
在这里插入图片描述

注释

Kotlin的注释与Java一致

// 单行注释
/*
多行注释
*/
/**
文档注释，KDoc，详见：dokka
 */

方法

方法默认为不可继承的静态方法，参数列表传入的值不能为null

//关键字 fun
//形参名: 类型
//fun 方法名(参数列表): 返回值类型 {方法体}
fun add(n1: Int, n2: Int): Int {
	return n1 + n2
}

add方法对应Java的方法如下。

public static final int add(int n1, int n2) {
	return n1 + n2;
}

如果需要去掉final（子类继承和访问），可以使用关键字open修饰fun。

class Main {
    open fun add(n1: Int, n2: Int): Int {
        return n1 + n2
    }
}

方法只有一行时，可以使用=替代{...}

fun add(n1: Int, n2: Int): Int = n1 + n2

数据类型

变量、常量

//变量
var i: Int = 1
//常量
val n: Int = 2

i = i + 1 //OK
n = n + 1 //ERROR, Val cannot be reassigned

原始数据类型

Kotlin没有基本数据类型，只有封装Java基本类型后的原始数据类型。

编译前都是包装的类型，编译时会进行判断（null的可能性检查），选择基本类型还是包装类型。

整数

类型	位宽	最小值	最大值
`Byte`	8	-128	127
`Short`	16	-32768	32767
`Int`	32	-2,147,483,648	2,147,483,647
`Long`	64	-9,223,372,036,854,775,808	9,223,372,036,854,775,807

整型默认为Int
Long类型的整数需要加尾缀L（必须大写）

浮点

类型	位宽	有效位数	指数位数	最小值	最大值
`Float`	32	24	8	1.4e-45	3.4028235e38
`Double`	64	53	11	4.9e-324	1.7976931348623157e308

浮点型默认为Double
Float需要加尾缀F
e标记的前后必须为10进制数，2e3表示2*10^3，不支持Java的p标记

字符

字符	位宽	精度范围
`Char`	16	\u0000~\uFFFF

Char类型废弃了所有转换为数字的方法。

var a: Char
var b: Int

a = 'A'
//Int -> Char
a = (65).toChar()
a = Char(65)
//Char -> Int
a = 'A'
b = a.code

布尔

布尔类型	范围
`Boolean`	`false`, `true`

无符号数字

类型	位宽	最大值
`UByte`	8	255
`UShort`	16	65535
`UInt`	32	4,294,967,295
`ULong`	64	18,446,744,073,709,551,615

var a: ULong
var b: UByte

a = 200UL
//Sign -> UnSign
b = (-10).toUByte() //246
//UnSign -> Sign
println(b.toByte()) //-10
//UnSign Calc
var c = a * b
println(c)//200*246=49200

无符号类型需要加尾缀U
无符号类型的变量不能直接与有符号类型的变量运算

进制

默认为10进制，16进制前缀为0x，2进制前缀为0b，不支持8进制。

数字和数字之间可以使用下划线_分隔。

数组

Array、IntArray、UIntArray…

字符串

String、"字符串"、"""原始字符串"""

数值类型的自动转换

原数据类型的精度范围在目标数据类型的范围内，可以自动转换。否则会因为丢失精度转换为错误的数值。

//Long转Int不能强制转换
var a: Int = 129L; //ERROR
//Int转Long自动转换
var b: Long = 129;
//超过最大值，最高位的进位丢失
var c = b.toByte() //-127

不同类型进行运算时，先自动转换为范围较大的类型，然后再运算（相同的类型才能进行运算）。

var a: Int = 129;
var b: Long = 129L;
var c = a * b //Long
println(c) //16641

表达式和语句

//这是条语句，其中 n = 1 是表达式
var n = 1

表达式有返回值，语句没有（等价于Java的Void）。

语句是程序的执行最小单元。

var n //声明语句
n = 1 //赋值语句（表达式加换行符）
n++ //自增语句
println(n) //方法调用语句

还有创建对象语句、控制流语句。

控制流语句

不支持goto。

`if`

用法

var a = 1
var b = 2
var max = a
//单行写法
if (a < b) max = b
//完整的写法
if (a > b) {
    max = a
} else if (a < b) {
    max = b
} else {
    TODO("一样大，什么也不做")
}
//表达式写法
max = if (a < b) b //ERROR
max = if (a > b) a else b //OK
max = if (a > b) { //OK
    println("Choose a")
    a //缺省 return 的返回值
} else {
    println("Choose b")
    b
}
println(max)

`when`

类似switch的用法，Java14、17、18都进行了加强，现在Java的switch和Kotlin的when用法相似。

val n = when (val s = readlnOrNull()) {
    null -> 0
    else -> s.length
}
println("输入了${n}个字符")

使用Range进行匹配。

fun main() {
    test(2)
}

fun test(v: Int) {
    when (v) {
        in 1..5 -> {
            println("工作日")
        } //不用担心break
        in setOf(6, 7) -> println("休息日")
        !in 1..7 -> {
            println("非法输入")
        }
    }
}

使用Set集合进行匹配，原理是比较HashCode值，所以Set集合是无序。

fun main() {
    test("绿", "红") //黄
}

fun test(a: String, b: String) {
    when (setOf(a, b)) {
        setOf("红", "绿") -> {
            println("黄")
        }
        setOf("红", "蓝") -> {
            println("紫")
        }
        setOf("蓝", "绿") -> {
            println("青")
        }
        else -> {
            println("非法输入")
        }
    }
}

数据类型匹配

fun main() {
    test(2)
}

fun test(v: Any) = when (v) {
    is String -> println("字符串")
    is Int -> println("数字")
    else -> println("未知")
}

`for`

//.. 正序：[0, 10]
for (i in 0..10) {
    //0 1 2 3 4 5 6 7 8 9 10
    print("$i ")
    //$ 字符串模板，格式化输出变量的值
}
//until 正序：[0, 10)
for (i in 0 until 10) {
    //0 1 2 3 4 5 6 7 8 9
    print("$i ")
}
//downTo 逆序：[10, 0]
//step 步进值
for (i in 10 downTo 0 step 3) {
    //10 7 4 1
    print("$i ")
}

`forEach`

val a: IntProgression = (10 downTo 0 step 3)
a.forEach { i -> //这里不写，默认形参为it
    //10 7 4 1
    print("$i ")
}

`do`、`while`

用法

while (/*布尔表达式*/true) {
    TODO("循环内容")
}
do {
    TODO("循环内容")
} while (/*布尔表达式*/true)

`label@`

跳出到指定代码块的标签

val gcd = lambda@{
    w1@ while (true) {
        while (true) {
            break
            continue@w1
            return@lambda
        }
    }
}

null

`Type?`

任何数据类型后面加?，表示这个类型的值可以为null

var a: Int? //可以为null
var b: Int //不可以为null

可以为null的类型不可以赋值给不能为null的类型

fun main() {
    var a: Int? = 1
    test1(a) //Int? 不可以向 Int 传参
    var b: Int = 1
    test2(b) //Int 可以向 Int? 传参
}

fun test1(a: Int) {
    println(a)
}

fun test2(a: Int?) {
    println(a)
}

可能为null的方法调用

var str: String? = null
//必须加?，返回值类型为Int?
var len = str?.length
println(len) //null

`?:`

可以为null的数据类型，可以使用Elvis操作符。

var str: String? = null
//左边为null时，执行右边
var len = str?.length ?: -1
println(len) //-1

`as?`

var str = "123"
//左边不为null时，强制转换为右边的类型
//不支持从父类强制转换为子类
//转换失败，结果为null
var b = str as? String
println(b) //123

`!!`

var str = "123"
//str必须为非null，否则抛出
//java.lang.NullPointerException
var b = str!!.length
println(b) //3

尽量避免使用非null断言（!!），会破坏kotlin对null的设计初衷。

var str: String? = "123"
str?.let {
//let：只有在str非null时执行
//避免直接调用str.length出现异常
//也避免了执行str?.length，出现不正常的结果
//it是默认传入的参数，不为null
    println(it.length) //3
}

或者直接退出，不执行后续代码，保证不产生不正常的结果和执行多余的步骤。

var str: String? = "123"
//如果为null，执行右边的代码退出（或者抛异常）
var s = str ?: return
println(s?.length) //3

var str: String? = "123"
//使用?:避免null引发后续代码的执行
//如果str为null，会出现非法值-1，不会进入执行
if ((str?.length ?: -1) >= 0) {
    println(str?.length) //3
}

包装类型和基本类型

编译时如果参数有?修饰，并且有null的可能，编译后为装箱的包装类型，否则会自动优化，都编译为基本数据类型。

//int
var a: Int = 1
//Integer
var b: Int? = null

集合和数组默认使用Java的包装类型，如果使用特定类型的arrayOf方法，则是Java的基本类型。

//List<Integer>
var list: List<Int> = listOf(1, 2, 3)
//Integer[]
//Array<T>的arrayOf方法
var arr1: Array<Int> = arrayOf(1, 2, 3)
//int[]
var arr2 = intArrayOf(1, 2, 3)

访问修饰符

修饰类和顶层成员

修饰符	Java最大访问范围	Kotlin最大访问范围
`public`	全局	全局
`protected`	相同包和所有子包	不支持
`internal`	不支持	相同模块
`default`、缺省	相同包	全局
`private`	源文件	源文件

修饰类的成员

修饰符	Java最大访问范围	Kotlin最大访问范围
`public`	全局	全局
`protected`	相同包和所有子包	所有子类
`internal`	不支持	相同模块
`default`、缺省	相同包	全局
`private`	类	类

访问权限的传递

继承访问权限时，访问修饰符的访问范围不能被放大，可以更严格（缩小可以访问的范围）。

数组

创建

fun main() {
    //Integer[]
    val arr1: Array<Int> = Array(3) { 1 }
    println(arr1.contentToString())//[1, 1, 1]

    val arr2: Array<Int> = arrayOf(1, 2, 3)
    println(arr2.contentToString())//[1, 2, 3]
    //int[]
    val arr3: IntArray = IntArray(3) { 1 }
    println(arr3.contentToString())//[1, 1, 1]
    val arr4: IntArray = intArrayOf(1, 2, 3)
    println(arr4.contentToString())//[1, 2, 3]
    //Integer[][]
    //IntArray只能是一维数组
    val arr5 = Array(3) { intArrayOf(0, 0, 0) }
    println(arr5.contentDeepToString())//[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
}

常用方法

`map`

将每一个元素操作后放回。

val arr = intArrayOf(1, 2, 3)
arr.map {
    it * 2
}.also {
    println(it) //[2, 4, 6]
}

`flatMap`

将每一个元素操作后放入一个集合，然后操作下一个元素时，将这个集合中的所有元素整合在一起，最后返回整合后的集合。

val arr = intArrayOf(1, 2, 3)
arr.flatMap {
    listOf(it * 2, 0)
}.also {
    println(it) //[2, 0, 4, 0, 6, 0]
}

`fold`

设置初始值，然后进行累计操作。

val arr = intArrayOf(1, 2, 3)
//初始值1，累加
arr.fold(1) { sum, i ->
    sum + i
}.also {
    println(it) //7
}

`associate`

将数组的元素转换为键值对，键相同时会不存放。

val arr = intArrayOf(1, 2, 3)
arr.associate {
    Pair(it, it * 2) //键值对
}.also {
    println(it) //{1=2, 2=4, 3=6}
}

//另一种写法，以数组的元素为键，存放特定的值，键相同时会不存放。
intArrayOf(1, 2, 3).associateWith { it * 2 }.also(::println)

将数组的元素按照特定的键进行存放，键相同时会不存放。

val arr = intArrayOf(1, 2, 3)
arr.associateBy {
    it * 2
}.also {
    println(it) //{2=1, 4=2, 6=3}
}

`distinct`

去重。已经存在时不存放。

val arr = intArrayOf(1, 2, 2)
arr.distinct().also {
    println(it) //[1, 2]
}

val arr = intArrayOf(1, 2, 3)
arr.distinctBy {
    it % 2
}.also {
    println(it) //[1, 2]
}

`Any`、`Unit`、`Nothing`

Kotlin	Java
Any	Object
Unit	Void
Nothing	没有对应的类型，编译后为Void

Any是所有类型的父类，Unit是表达式没有返回值时用来替代的一种类型。

`Nothing`

不可以实例化，是所有类型的子类，常用在抛出异常的方法，作为返回值类型（只抛出异常，没有什么可以返回）。

fun main() {
    var str = "123"
    var len = size(str)
    println(len)
}

fun size(str: String?): Int {
    return str?.length ?: error("不能为null")
}

//不加Nothing，size方法会报错，error方法返回的是Unit类型，与size方法返回类型不兼容
//加Nothing，编译器会检测出异常出现的位置，判断出死代码的范围并提醒
//Nothing是所有类型的子类，与size方法的Int返回类型兼容
fun error(msg: String): Nothing {
    throw RuntimeException(msg)
}

集合

包路径：kotlin.collections.*

不可变集合

只能查询集合中的元素，不能修改。

优点：

被不可信任的库调用时，不可变集合更安全。
在多线程环境下，没有并发的安全性问题。
不可变集合节省内存空间，不需要扩容

val list: List<Int> = listOf(1, 2, 3)
println(list.javaClass)//java.util.Arrays$ArrayList
println(list)//[1, 2, 3]

val set: Set<Int> = setOf(1, 2, 3)
println(set.javaClass)//java.util.LinkedHashSet
println(set)//[1, 2, 3]

val map: Map<Int, String> = mapOf(
	1 to "01", 2 to "02", 3 to "03"
)
println(map.javaClass)//java.util.LinkedHashMap
println(map)//{1=01, 2=02, 3=03}

可变集合

可以对集合中的元素进行增删改查。

val list: List<Int> = mutableListOf(1, 2, 3)
println(list.javaClass)//java.util.ArrayList
println(list)//[1, 2, 3]

val set: Set<Int> = mutableSetOf(1, 2, 3)
println(set.javaClass)//java.util.LinkedHashSet
println(set)//[1, 2, 3]

val map: Map<Int, String> = mutableMapOf(
	1 to "01", 2 to "02", 3 to "03"
)
println(map.javaClass)//java.util.LinkedHashMap
println(map)//{1=01, 2=02, 3=03}

val list: List<Int> = arrayListOf(1, 2, 3)
println(list.javaClass)//java.util.ArrayList
println(list)//[1, 2, 3]

val set: Set<Int> = hashSetOf(1, 2, 3)
println(set.javaClass)//java.util.HashSet
println(set)//[1, 2, 3]

val map: Map<Int, String> = hashMapOf(
	1 to "01", 2 to "02", 3 to "03"
)
println(map.javaClass)//java.util.HashMap
println(map)//{1=01, 2=02, 3=03}

val set: Set<Int> = linkedSetOf(1, 2, 3)
println(set.javaClass)//java.util.LinkedHashSet
println(set)//[1, 2, 3]

val map: Map<Int, String> = linkedMapOf(
	1 to "01", 2 to "02", 3 to "03"
)
println(map.javaClass)//java.util.LinkedHashMap
println(map)//{1=01, 2=02, 3=03}

val set: Set<Int> = sortedSetOf(1, 2, 3)
println(set.javaClass)//java.util.TreeSet
println(set)//[1, 2, 3]

val map: Map<Int, String> = sortedMapOf(
	1 to "01", 2 to "02", 3 to "03"
)
println(map.javaClass)//java.util.TreeHashMap
println(map)//{1=01, 2=02, 3=03}

常用方法

val list: List<Int> = listOf(1, 2, 3)
//有一个不满足，返回false
list.all { n -> n == 3 }
	.apply { println(this) }//false
//有一个满足条件，返回true
list.any { n -> n != 3 }
	.apply { println(this) }//true
//统计满足条件的元素个数
list.count { it >= 2 }
	.apply { println(this) }//2
//寻找第一个满足条件的元素
list.find { n -> n >= 2 }
	.apply { println(this) }//2
list.firstOrNull { n -> n >= 2 }
	.apply { println(this) }//2
//按条件分组
list.groupBy { n -> n % 2 }
	.apply { println(this) }//{1=[1, 3], 0=[2]}
//过滤不符合条件的元素
list.filter { n -> n % 2 == 0 }
	.apply { println(this) }//[2]
//寻找最大值
listOf("asx", "s", "qza", "amount")
	.maxByOrNull(String::length)
	.apply { println(this) }//amount

序列

集合调用filter方法和map等处理元素的方法时，会创建中间临时集合对象进行封装。为了避免这个过程，引入sequence序列。

var list: List<Int> = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
list = list.asSequence()
    //[5,6,7,8,9,a]，不执行
    .filter { n -> n > 4 }
    //[a,c,e,10,12,14]，不执行
    .map { n -> n * 2 }
    //归集方法
    .toList()
    //开始执行序列设计好的上述过程
    //每个元素都会经过上述操作，避免中间创建临时对象
println(
    //序列格式化输出
    list.joinToString(
        "[", //左边界
        ",", //分隔符
        "]", //右边界
        10, //最多显示的元素个数
        "...", //超出限制数量不显示的元素，使用填充
        { it.toString(16) } //转换元素
    )
)

字符串

比较

fun main() {
    //创建
    val str = "abcDefgHi"
    val str1 = "$str" + " " + "${str.length}"
    val str2 = buildString {
        append("abcdefghi").append(' ').append(str.length)
    }
    
    //内容相同（引用可能不同），false
    (str1 == str2).ptl()
    //引用相同，false
    (str1 === str2).ptl()
    //忽略大小写比较，true
    (str1.equals(str2, true)).ptl()
    //匹配前缀，true
    (str1.startsWith("AB", 0, true)).ptl()
    //匹配后缀，false
    (str1.endsWith("hi", true)).ptl()
}

//扩展方法：为特定类型添加方法（并未修改源文件）
//作用域受这个方法的修饰词控制
fun Any?.ptl() {
    println(this)
}

处理

fun main() {
    //获取第一个字符
    "abcDefgHi"[0].ptl() //a
    //长度为0的字符串=>NoSuchElementException
    "abcDefgHi".first().ptl() //a
    //长度为0的字符串=>null
    "abcDefgHi".firstOrNull().ptl() //a
    
    //获取最后一个字符
    "abcDefgHi".last().ptl() //i
    "abcDefgHi".lastOrNull().ptl() //i
    "abcDefgHi".lastOrNull { it == 'c' }.ptl() //c
    
    //截取
    "abcDefgHi".drop(3).ptl() //DefgHi
    "abcDefgHi".dropLast(3).ptl() //abcDef
    
    //删除前后特定字符
    "_1_234_567_".removeSurrounding("_").ptl() //1_234_567
    
    //分组
    "1,23_4,567".split("_", ",").ptl() //[1, 23, 4, 567]
    
    //设置默认值
    " \n \r \t".ifBlank { "空字符串" }.ptl()
    "".ifEmpty { "0长度字符串" }.ptl()
    
    //资源路径截取
    val path = "C:\\Windows\\System32\\cmd.exe"
    //文件名
    path.substring(path.lastIndexOf('\\') + 1).ptl()
    path.removeRange(0..path.lastIndexOf('\\')).ptl()
    path.substringAfterLast('\\').ptl()//推荐
    //批量去除后缀名
    listOf("1.jpg", "2.jpg", "3.jpg").map { it.removeSuffix(".jpg") }.forEach(::println)
    listOf("1.jpg", "2.png", "3.tiff").map { it.substringBefore(".") }.forEach(::println)
    
    //首字母大写
    "system".capitalize().ptl()
    "system".replaceFirstChar {
        if (it.isLowerCase()) {
            it.titlecase(Locale.getDefault())
        } else {
            it.toString()
        }
    }.ptl()
}

fun Any?.ptl() {
    println(this)
}

原始字符串

fun main() {
    //转义符失效
    """
    asdf \t \n \r 123
    """.ptl()
    //保留每一行和前面的空格
    
    """
    asdf \t \n \r 123
    """.trimIndent().ptl()
    //删除前后的空行和左边的空格
    
    """
    |public static void main(String[] args) {
    |System.out.println("Hello World!");
    |}
    """.trimMargin("|").ptl()
    //默认以”|“字符为左边界，删除左边的字符和多余的空行
    
    //支持拼接
    ("""123""" + """sada""" + "125").ptl()
}

fun Any?.ptl() {
    println(this)
}

泛型

型变、约束

open class Animal //动物
open class Dog : Animal() //狗
open class Shiba : Dog()//柴犬

open class Shop<T> {
    fun run(t: T?): T? = t
}

fun main() {
    //out：协变，<? extends Dog>，子类泛型可以赋值给父类泛型
    val s1: Shop<out Dog> = Shop<Animal>() //error
    val s2: Shop<out Dog> = Shop<Dog>()
    val s3: Shop<out Dog> = Shop<Shiba>()
    val s2run: Dog? = s2.run(/*Nothing*/null)//能获取，不能传入
    //in：逆变，<? super Dog>，父类泛型可以赋值给子类泛型
    val s4: Shop<in Dog> = Shop<Animal>()
    val s5: Shop<in Dog> = Shop<Dog>()
    val s6: Shop<in Dog> = Shop<Shiba>() //error
    val s5run: Any? = s5.run(Dog())//能传入，不能获取
    //不变，<Dog>，类型被限定
    val s7: Shop<Dog> = Shop<Animal>() //error
    val s8: Shop<Dog> = Shop<Dog>()
    val s9: Shop<Dog> = Shop<Shiba>() //error
    val s8run: Dog? = s8.run(Dog())//能获取，能传入
    //投影，<in Nothing>，<out Any>，类型不被限定
    val s10: Shop<*> = Shop<Animal>()
    val s11: Shop<*> = Shop<Dog>()
    val s12: Shop<*> = Shop<Shiba>()
    val s11run: Dog? = s8.run(Dog())//能获取，能传入
}

方法

可选参数

import kotlin.math.pow

//参数拥有默认值后，变为可选参数，不需要赋值也可以使用
fun pow(
    a: Double = .0,
    base: Double = 10.0,
    c: Double = 1.0
) = a + base.pow(c) //表达式方法

fun main() {
//跨参数赋值可以使用参数名指定
    println(pow(1.0, c = 3.0)) //1001.0
}

`vararg`

参数的数量可以不固定，使用vararg修饰的参数为可变长度的参数，本质是一个数组。

位置不受限制，放在固定参数的前边是数组，放在后边是Java的T...。

fun add(vararg arr: Int, last: Int): IntArray {
    val temp = arr.copyOf(arr.size + 1)
    temp[arr.size] = last
    return temp
}

fun main() {
    //println(add(last = 0))//ERROR

    //[0]
    println(add(last = 0).contentToString())

    //[1, 2, 0]
    println(add(1, 2, last = 0).contentToString())

    //[1, 2, 3, 4, 0]
    println(add(1, 2, 3, 4, last = 0).contentToString())
}

`*`

展开参数的操作符。避免将int[]传入T...时，int[]被当作一个元素的T。

fun main() {
    val arr = arrayOf(1, 2, 3)
    //识别为一个对象
    //public fun <T> listOf(element: T): List<T>
    listOf(arr).run { println("$size") } //1
    //数组也是一个对象，使用*后，匹配vararg形参
    //public fun <T> listOf(vararg elements: T): List<T>
    listOf(*arr).run { println("$size") } //3
}

`infix`

两个相同类型的形参方法，使用infix修饰方法，可以放在两个相同的参数之间，不需要使用点和括号的方法，构成中缀表达式的语法。

infix fun Int.max(that: Int) = this.coerceAtLeast(that)

fun main() {
    //相当于 5.max(6)
    println(5 max 6)//6
}

for循环的until、downTo、step使用了中缀表达式。

Map的键值对使用key to value的方式生成Pair对象。

扩展方法

在方法名前使用类型名进行指定扩展的方法。并没有在指定类型的源文件中进行扩展。

//为所有类型扩展ptl方法
//在哪里扩展，从哪里来调用
fun Any?.ptl() {
    println(this)
}

局部方法

方法里面嵌套的方法。

fun main() {
    fun max(a: Int, b: Int) = a.coerceAtLeast(b)
    max(5, 6).ptl()//6
}
fun Any?.ptl() = println(this)

匿名方法

fun main() {
    (fun(a: Int, b: Int): Int {
        return a.coerceAtLeast(b)
    })(5, 6).ptl()//6
}
fun Any?.ptl() = println(this)

进阶篇

类

构造方法

创建对象时用于初始化类属性的方法，返回创建的对象。

在类名后为一级构造方法，在类内为二级构造方法。

//一级构造方法的参数如果没有被var、val标记
//不会生成属性、get、set方法
//constructor可以省略
open class Person constructor(var name: String) {
    var age: Int = 0

    //二级构造方法的参数不可以被var、val标记
    constructor(name: String, age: Int) : this(name) {
        this.age = age
    }
}

//顶级成员类的构造方法私有化
//object 类名
object Man

伴生对象

伴生对象：静态类成员。每个类只能有一个伴生对象

open class Math {
    //companion object name
	//name缺省时，默认名为：Companion
    companion object Const{
        //公共常量
        const val INT_MAX: Int = Int.MAX_VALUE
        //私有常量
        val INT_MIN: Int = Int.MIN_VALUE
        //静态变量
        var INT_BITS: Int = Int.SIZE_BITS
        //静态方法
        fun max(x: Int, y: Int): Int {
            return x.coerceAtLeast(y)
        }
    }
}

fun main() {
    Math.INT_MAX //Kotlin直接调用
    Math.Const.INT_MAX //兼容Java的调用
}

单例模式

（主要是了解构造方法怎么私有化。）

饿汉

//将构造方法私有化
object Person

fun main() {
    val p1 = Person
    val p2 = Person
    println(p1 === p2)//true
}

懒汉

//将构造方法私有化
class Person private constructor() {
    companion object {
        private var INSTANCE: Person? = null
        fun getInstance(): Person {
            if (INSTANCE === null) {
                //创建并保存单例对象
                INSTANCE = Person()
            }
            return INSTANCE!!
        }
    }
}

fun main() {
    val p1 = Person.getInstance()
    val p2 = Person.getInstance()
    println(p1 === p2)
}

线程安全的懒汉

class Person private constructor() {
    companion object {
        private var INSTANCE: Person? = null
        @Synchronized //这个方法将被加上同步锁关键字
        fun getInstance(): Person {
            if (INSTANCE === null) {
                INSTANCE = Person()
            }
            return INSTANCE!!
        }
    }
}

fun main() {
    val p1 = Person.getInstance()
    val p2 = Person.getInstance()
    println(p1 === p2)
}

双重校验锁

class Person private constructor() {
    companion object {
        private val INSTANCE: Person by lazy(
            //懒加载的同步锁
            mode = LazyThreadSafetyMode.SYNCHRONIZED
        ) {
            return@lazy Person()
        }
        fun getInstance(): Person {
            return INSTANCE
        }
    }
}

fun main() {
    val p1 = Person.getInstance()
    val p2 = Person.getInstance()
    println(p1 === p2)
}

静态内部类模式

class Person private constructor() {
    companion object {
        private object PersonSingleton {
            val singleton = Person()
        }

        private val INSTANCE: Person = PersonSingleton.singleton
        fun getInstance(): Person {
            return INSTANCE
        }
    }
}

fun main() {
    val p1 = Person.getInstance()
    val p2 = Person.getInstance()
    println(p1 === p2)
}

匿名内部类对象

class Person {
    fun main() {
        //抽象类不能创建对象，但是实现全部方法后
        //就可以创建内部类的匿名对象
        //然后直接调用对象的方法
        object : AbstractCollection<Int>() {
            override val size: Int
                get() = TODO()

            override fun iterator(): Iterator<Int> {
                TODO()
            }
        }.stream().forEach(::println)
    }
}

`init`

初始化代码块。创建对象，初始化类时，最先被执行的代码。

class Person {
    //会添加到一级构造方法中，每次创建对象时最先执行
    //如果没有一级构造方法，则添加到每一个二级构造方法中
    //如果在companion中，自动转换为static{ }
    init {
        TODO()
    }
}

`inner`

创建的内部类默认为静态内部类，如果需要去掉静态，使用关键字inner

open class Person {
    //public static final
    class Man {
    }

    //public final
    inner class Woman {
    }
}

`sealed`

密封类：枚举的扩展。被标记后是抽象类。

sealed class Person {
    class Man() : Person()
    class Woman() : Person()
}

fun func(p: Person) {
    when (p) {
        is Person.Man -> println("男")
        is Person.Woman -> println("女")
        else -> println("中性") //多余的分支
    }
}

`data class`

数据类：自动为一级构造方法的属性创建一些特殊的方法。只对一级构造方法的参数有用。

//equals() / hashCode()
//toString() 格式如 "Person(name=John, age=42)"
//componentN() functions 对应于属性，按声明顺序排列
//copy() 函数
data class Person(var id: Int)

`interface`

接口类。

interface IPerson {
    //接口的属性不允许赋值，实现时必须重写，get和set方法为抽象方法
    var id: Int

    //如果没有方法体，为抽象方法
    //如果有方法体，除了抽象方法，还将实现封装在DefaultImpls类中，成为默认方法
    fun idPlus() {
        id++
    }
}

class Person : IPerson {
    //override 重写接口中的成员
    override var id: Int = 0
    override fun idPlus() {
        //调用默认方法
        super.idPlus()
        println(id)
    }
}

类的成员

类由多个字段和方法构成。

字段、属性

属性的声明由val、var标记，一级构造方法也是如此。

被abstract修饰的抽象成员可以不用初始化赋值。

被private标记，没有set、get方法
被val标记，为属性，只有get方法
被var标记，为属性，set、get方法都有

class Person {
    //Field 类的字段。
    private val id = 0 //字段

    //Property 字段和对应的get、set方法组成类的属性。
    val age = 0 //age属性
    var name = "" //name属性
}

fun main() {
    val p = Person()
    val fields = p.javaClass.declaredFields
    for (field in fields) {
        println(field.name)
    }
}

`field`

手动为属性添加get和set方法

class Person {
    val age: Int = 18
        //field指代这个属性的值，使用this.age会出现无限的嵌套调用
        get() = field
    var name: String = "无名氏"
        //get方法不可以私有化，属性必须可读
        get() {
            return field
        }
        //set方法可以私有化，只供内部调用
        private set(name) {
            if (name.isNotEmpty()) field = name
        }
}

`const`

常量，只能修饰原始类型和字符串。

class Person {
    //常量必须放在伴生对象中
    companion object {
        //public static final
        const val MAN = 1
        const val WOMAN = 2
    }
}

`lateinit`

懒加载的属性不可以为原始数据类型（不能为null）

class Person {
    //属性只能为使用var修饰，可以不用初始化
    lateinit var name: String
    override fun toString(): String {
        if (this::name.isInitialized.not()) this.name = ""
        //如果调用没有初始化的属性，将抛出异常
        //UninitializedPropertyAccessException
        return "Person(name='$name')"
    }
}

fun main() {
    val p = Person()
    //Person(name='')
    println(p.toString())
    p.name = "张三"
    //Person(name='张三')
    println(p.toString())
}

委托

`by`

属性的get和set方法实现，可以委托给别的类的对象进行重载。

import kotlin.reflect.KProperty

class Name {
    //使用委托对象后，这个委托对象没有name字段，只有name字段的get和set方法的重载
    //operator 重载
    operator fun getValue(p: Person, pro: KProperty<*>): String {
        println("getValue： 将 ${pro.name} 委托到 ${this.toString()} 来处理")
        return pro.name
    }

    operator fun setValue(p: Person, pro: KProperty<*>, s: String) {
        println("setValue： 将 $s 委托到 ${this.toString()} 来处理，然后交给 ${pro.name}")
    }
}

class Person {
    //委托Name对象完成get和set方法的实现
    var name: String by Name()
    override fun toString(): String {
        return "Person(name='$name')"
    }
}

fun main() {
    val p = Person()
    p.name = "123"
    println(p.toString())
}

`by lazy`

import kotlin.concurrent.thread

class Person {
    //延迟加载的属性只能使用val修饰
    private val name: String by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
        println("${Thread.currentThread().id.toString()} lazy")
        "123"
    }

    override fun toString(): String {
        Thread.sleep(10)
        return "${Thread.currentThread().id.toString()} Person(name='$name')"
    }
}

fun main(args: Array<String>) {
    val p = Person()
    repeat(10) {
        thread(name = "线程:${it}") {
            println(p.toString())
        }
    }
}

LazyThreadSafetyMode

SYNCHRONIZED：默认，多线程环境下，只会执行一次，然后任何线程就不会再执行
PUBLICATION：多个线程都可能会执行一次，直到检测到已经初始化后不再执行
NONE：没有线程安全的保障，只能在单线程中安全的使用

`by Delegates.observable`

属性的值发生变化时的监听处理。

import kotlin.properties.Delegates

class Person {
    //设置初始值<init>
    var name: String by Delegates.observable("<init>") { pro, old, new ->
        //然后每次变化前会执行这个方法
        println("属性名：${pro.name} , ${old} -> ${new}")
    }

    override fun toString(): String {
        return "Person(name='$name')"
    }
}

fun main() {
    val p = Person()
    p.name = "A"
    p.name = "B"
    println(p.toString())
}

`by map`

使用Map对象初始化对象的属性值。键是属性名，值是属性值。

class Person(val map: Map<String, Any>) {
    private val id: Int by map
    private val name: String by map
    override fun toString(): String {
        return "Person(id=$id, name='$name')"
    }
}

fun main() {
    val p = Person(hashMapOf("id" to 1, "name" to "a"))
    println(p.toString())
}

委托模式

当两个子类（继承同一个类）的实现完全一致，可以只实现一个子类，另一个子类交给这个类去实现。一处修改，另一个自动修改。

interface People {
    fun talk()
}

class Man : People {
    override fun talk() {
        println("talk")
    }
}

//Woman使用代理对象man实现接口，实现和Man类完全一致
class Woman(private val man: Man = Man()) : People by man

fun main() {
    val w = Woman()
    w.talk()
}

枚举

可以约束传参时的值在合理的范围区间。

enum class Color(var color: Int) {
    RED(0xFF0000),
    WHITE(0xFFFFFF),
    BLACK(0x000000),
    GREEN(0x00FF00)
}

fun toString(color: Color): String {
    //when判断枚举
    return when (color) {
        Color.RED -> "红"
        Color.BLACK -> "黑"
        Color.GREEN -> "绿"
        Color.WHITE -> "白"
    }
}

fun main() {
    println(toString(Color.WHITE))
}

密封类和枚举对比

密封类比枚举类更灵活。常用来表示受限制的类继承结构（密封类中的内部类都必须继承这个密封类）。

枚举中，每个枚举值都是枚举的单例，密封类中的子类可以不是单例（更自由灵活）。

密封类的子类都必须在这个密封类中，但是密封类子类的子类不受限制。

密封类是抽象类，不能实例化，内部的子类可以实例化。

常用方法

import java.io.Serializable

//枚举可以实现接口，不能继承类
enum class Country : Serializable {
    USA {
        //匿名内部类，重载方法
        override fun toString(): String = "美国"
    },
    KR,
    JP;
}

fun main() {
    //名称
    Country.USA.ptl()//美国
    Country.USA.name.ptl()//USA
    //序号，when索引时底层使用
    Country.JP.ordinal.ptl()//2
    //使用name获取枚举值
    //不存在抛出异常java.lang.IllegalArgumentException
    Country.valueOf("USA").ordinal.ptl()//0
    //输出全部枚举值
    Country.values().toList().ptl()//[美国, KR, JP]
}

fun Any?.ptl() = println(this)

实例域

使用枚举时不推荐使用ordinal、name（序列化和反序列化出现差异时无法避免null），不推荐作为接口的返回类型。

//使用实例域代替ordinal序数，避免枚举发生变化时，无法对应
enum class Country(val id: Int) {
    USA(101),
    KR(201),
    JP(202);
}

fun main() {
    Country.USA.id.ptl()
}

fun Any?.ptl() = println(this)

操作符重载

https://github.com/JetBrains/kotlin/blob/1.8.0/spec-docs/operator-conventions.md

import kotlin.math.abs
import kotlin.math.max
import kotlin.math.min
//分数类
class Fraction private constructor() {
    private var p: Int = 0 //分子
    private var q: Int = 0 //分母

    constructor(p: Int, q: Int) : this() {
        if (q == 0) throw Exception("q != 0")
        if (q < 0) {
            this.q = -q
            this.p = -p
        }
        val g = gcd(abs(p), q)
        this.p = p / g
        this.q = q / g
    }

    //this + a
    operator fun plus(a: Fraction): Fraction {
        return Fraction(a.p * this.q + a.q * this.p, a.q * this.q)
    }

    //this += a
    operator fun plusAssign(a: Fraction) {
        val f = this + a
        this.p = f.p
        this.q = f.q
    }

    //-this
    operator fun unaryMinus(): Fraction {
        return Fraction(-this.p, this.q)
    }

    //this - a
    operator fun minus(a: Fraction): Fraction {
        return this + -a
    }

    //this * a
    operator fun times(a: Fraction): Fraction {
        return Fraction(this.p * a.p, this.q * a.q)
    }

    //this / a
    operator fun div(a: Fraction): Fraction {
        return Fraction(this.p * a.q, this.q * a.p)
    }

    //this % a
    //operator fun rem(other: Fraction): Fraction
    companion object {
        fun gcd(a: Int, b: Int): Int {
            if (a == 0 || b == 0) return 0
            var t: Int
            var max: Int = max(a, b)
            var min: Int = min(a, b)
            while (max % min != 0) {
                t = max % min
                max = min
                min = t
            }
            return min
        }
    }

    private fun toDouble(): Double {
        return p.toDouble() / q
    }

    override fun toString(): String {
        return toDouble().toString()
    }
}

fun main() {
    val f_2_3 = Fraction(2, 3)
    val f_3_7 = Fraction(3, 7)
    println(f_2_3 - f_3_7) //0.23809523809523808
    println(f_2_3 * f_3_7) //0.2857142857142857
    println(f_2_3 / f_3_7) //1.5555555555555556
    f_2_3 += f_3_7
    println(f_2_3) //1.0952380952380953
}

一元操作符

操作符	函数名	接口方法
`+ a`	`unaryPlus`	`operator fun unaryPlus(): T`
`- a`	`unaryMinus`	`operator fun unaryMinus(): T`
`! a`	`not`	`operator fun not(): Boolean`
`++a`	`inc`	`operator fun inc(): T`
`a++`	`inc`	`operator fun inc(): T`
`--a`	`dec`	`operator fun dec(): T`
`a--`	`dec`	`operator fun dec(): T`

基本运算符

操作符	函数名	接口方法示例
`a + b`	`plus`	`operator fun plus(t: T): T`
`a - b`	`minus`	`operator fun minus(t: T): T`
`a * b`	`times`	`operator fun times(t: T): T`
`a / b`	`div`	`operator fun div(t: T): T`
`a % b`	`rem`	`operator fun rem(t: T): T`

复合赋值操作运算符

操作符	函数名	接口方法示例
`a += b`	`plusAssign`	`operator fun plusAssign(t: T)`
`a -= b`	`minusAssign`	`operator fun minusAssign(t: T)`
`a *= b`	`timesAssign`	`operator fun timesAssign(t: T)`
`a /= b`	`divAssign`	`operator fun divAssign(t: T)`
`a %= b`	`remAssign`	`operator fun remAssign(t: T)`

如果只重载了plus运算符，执行a+=b时，自动展开为a=a+b，然后调用plus方法。

如果同时重载了plusAssign、plus运算符，执行a+=b时，直接调用plusAssign方法。

按位操作符

Kotlin没有Java的按位操作符，通过中缀方法实现。

操作符	函数名	接口方法示例
`a & b`	`a and b`	`infix fun and(t: T): T`
`a \| b`	`a or b`	`infix fun or(t: T): T`
`~ a`	`a inv b`	`operator fun inv(): T`
`a ^ b`	`a xor b`	`infix fun xor(t: T): T`
`a << b`	`a shl b`	`infix fun shl(t: T): T`
`a >> b`	`a shr b`	`infix fun shr(t: T): T`
`a >>> b`	`a ushr b`	`infix fun ushr(t: T): T`

比较操作符

操作符	函数名	接口方法示例
`a == b`	`equals`	`override fun equals(other: Any?): Boolean`
`a != b`	`!(equals)`	`override fun equals(other: Any?): Boolean`
`a < b`	`compareTo < 0`	`operator fun compareTo(other: BigUInt): Int`
`a <= b`	`compareTo <= 0`	`operator fun compareTo(t: T): Int`
`a > b`	`compareTo > 0`	`operator fun compareTo(t: T): Int`
`a >= b`	`compareTo >= 0`	`operator fun compareTo(t: T): Int`

=== 、!==运算符不支持扩展函数的操作符重载。

索引操作符

操作符	函数名	接口方法示例
`v = a[b]`	`get(b)`	`operator fun get(n: Int): T`
`v = a[x, y]`	`get(x, y)`	`operator fun get(x: Int, y: Int): T`
`a[b] = v`	`set(b, v)`	`operator fun set(n: Int, v: T)`
`a[x, y] = v`	`set(x, y, v)`	`operator fun set(x: Int, y: Int, v: T)`

可以为多个参数。

调用操作符

操作符	函数名	接口方法示例
`a(b)`	`a.invoke(b)`	`operator fun invoke(b: Int)`
`a(x, y)`	`a.invoke(x, y)`	`operator fun invoke(x: Int, y: Int)`

可以为多个参数。

`in`操作符

判断存在于某个范围内。遍历数组或集合。

操作符	函数名	接口方法示例
`a in b`	`b.contains(a)`	`operator fun contains(t: T): Boolean`
`a !in b`	`!b.contains(a)`	`operator fun contains(t: T): Boolean`
`for(a in b)`	`b.iterator(){a}`	`operator fun iterator(): Iterator<T>`

区间操作符

操作符	函数名	接口方法示例
`a..b`	`a.rangeTo(b)`	`operator fun rangeTo(t: T): ClosedRange<out Comparable<T>>`

解构操作符

componentN

class Fraction(private var a: Int, private var b: Int) {
    operator fun component1(): Int {
        return this.a
    }
    operator fun component2(): Int {
        return this.b
    }
}

fun main() {
    val f = Fraction(1, 3)
    //a=>component1,b=>component2
    val (a, b) = f
}

两个返回值元组类：kotlin.Pair
三个返回值元组类：kotlin.Triple

`（反引号）

反引号可以解决关键字冲突的问题，强行将一个不合法的字符变为合法。

fun main(args: Array<String>) {
    val r = 2 `**` 3
    `This is a println function`(r)
}

//自定义运算符
infix fun Number.`**`(b: Number): Double {
    return Math.pow(this.toDouble(), b.toDouble())
}

//自定义方法名，空格不受命名规则限制
fun `This is a println function`(text: Any) {
    println(text)
}

文件

读写

import java.io.File
import kotlin.random.Random

fun main() {
    //文件不存在会自动创建
    val write = File("""D:\1.txt""")
    if (write.exists().not()) write.createNewFile()
    //覆盖
    write.writeBytes("123".toByteArray(Charsets.UTF_8))
    write.writeText("123") //默认使用UTF-8编码
    //追加
    write.appendBytes("12".toByteArray())
    write.appendText("12")
    //使用Java的IO流，完全覆盖
    write.outputStream().use {
        val sb = StringBuilder()
        for (i in 0..10) {
            sb.append(Random.nextInt(0x4E00, 0x9FA5).toChar())
        }
        //默认使用UTF-8编码
        it.write(sb.toString().toByteArray())
    }

    //文件不存在，抛出FileNotFoundException
    val read = File("""D:\1.txt""")
    //按行读取
    ptl { sb ->
        read.forEachLine { sb.append(it) }
    }
    //按数组块大小读取
    ptl { sb ->
        read.forEachBlock { buffer: ByteArray, n: Int ->
            //默认的块大小是4096，块大小不能小于512
            sb.append(buffer.decodeToString(0, n))
        }
    }
    //按字节读取
    ptl { sb ->
        read.inputStream().use {
            var value: Int = it.read()
            while (value != -1) {
                sb.append(value.toString(16)).append(" ")
                value = it.read()
            }
        }
    }
    //使用缓冲区
    ptl { sb ->
        read.inputStream().use {
            val buffer = ByteArray(1024)
            var n: Int
            do {
                n = it.read(buffer, 0, buffer.size)
                if (n == -1) break
                sb.append(buffer.decodeToString(0, n))
            } while (true)
        }
    }

    //使用缓冲流
    ptl { sb ->
        read.bufferedReader().use {
            it.readLine().forEach { sb.append(it.toString()) }
        }
    }
}

//高阶函数，内联函数
inline fun ptl(f: (sb: StringBuilder) -> Unit) {
    val str = StringBuilder()
    f(str)
    println(str)
}

遍历

import java.io.File

fun main() {
    val file: File = File("C:\\Windows\\System32\\cmd.exe")
    println(file.name) //cmd.exe
    println(file.nameWithoutExtension) //cmd
    println(file.extension) //exe

    File("C:\\")
        //父目录
        //.parentFile
        //访问
        .walk()
        //遍历深度
        .maxDepth(Int.MAX_VALUE)
        //过滤后缀
        .filter { it.extension.equals("log", true) }
        .forEach {
            println(it.absolutePath)
            it.delete()
        }
}

拷贝

import java.io.File

fun main() {
    val file = File("""D:\1.txt""")
    //文件拷贝
    //当前目录复制粘贴
    file.copyTo(File(file.parent, "3.txt"), overwrite = true)
    //目录拷贝
    file.parentFile?.copyRecursively(
        //文件所在的目录拷贝到另一个目录
        File(file.parentFile.parent, "2"), overwrite = true
    )
}

异常

kotlin的异常捕获由程序员来评估，自行捕获或规避。

如果通过编译器提醒进行捕获，滥用检查性异常会导致代码冗余，过多不想处理的异常不断向上抛出。

import java.io.File

class EmptyFileException(message: String?) : Exception(message)

fun main() {
    //不需要捕获异常，所有的异常都是unchecked exception
    val file = File("C:\\Windows\\System32\\cmd.exe")
    println(file.absolutePath)
    //根据需要抛出异常
    if (file.length() == 0L) throw EmptyFileException("没有内容")

    val str = ""
    try {
        str.toInt() //制造一个异常
    } catch (e: NumberFormatException) {
        println("$e $str is empty")
    }
}

高级篇

注解

元注解

注解类中用来描述注解类特性的注解。

//Flag注解一直存活到编译后
@Retention(AnnotationRetention.RUNTIME)
//可以在同一个位置重复标记
@Repeatable
//Flag重复标记时，会存放在Flag$Container注解容器
//如果需要指定注解容器，Java调用时兼容
@JvmRepeatable(Flags::class)
//被标记的成员将生成API文档
@MustBeDocumented
annotation class Flag

//Flag注解被Target限制在只能在字段和属性上标记
@Target(AnnotationTarget.FIELD, AnnotationTarget.ANNOTATION_CLASS)
annotation class Flags(val value: Array<Flag>) //必须使用val

AnnotationTarget	描述
`CLASS`	类
`ANNOTATION_CLASS`	注解类
`TYPE_PARAMETER`	泛型形参
`PROPERTY`	属性
`FIELD`	字段、枚举常量
`LOCAL_VARIABLE`	局部变量
`VALUE_PARAMETER`	方法形参
`CONSTRUCTOR`	构造方法
`FUNCTION`	方法
`PROPERTY_GETTER`	属性的获取方法
`PROPERTY_SETTER`	属性的设置方法
`TYPE`	类型
`EXPRESSION`	表达式
`FILE`	源文件
`TYPEALIAS`	类型别名

AnnotationRetention	描述
`SOURCE`	源码可见，编译后无法获取
`BINARY`	编译后可见，运行时无法获取
`RUNTIME`	运行时可以获取

位置注解

更精确的添加注解。

@file:Flag//将Flag注解添加到源码

@Target(
    AnnotationTarget.FILE,
    AnnotationTarget.VALUE_PARAMETER,
    AnnotationTarget.LOCAL_VARIABLE,
    AnnotationTarget.PROPERTY,
    AnnotationTarget.PROPERTY_GETTER,
    AnnotationTarget.PROPERTY_SETTER,
    AnnotationTarget.FIELD,
    AnnotationTarget.FUNCTION
)
annotation class Flag

class Person {

    //根据Target注解顺序指定
    //优先级：参数->属性->字段
    //get添加到getId$annotations
    @Flag
    var id: Int = 0

    @field:Flag //字段上添加Flag注解
    @property:Flag//属性上添加Flag注解
    @get:Flag //getXXX方法上添加Flag注解
    @set:Flag //setXXX方法的参数上添加Flag注解
    @setparam:Flag//setXXX方法上添加Flag注解
    var name: String = ""

    @delegate:Flag//属性委托的XXX$delegate字段上添加Flag注解
    val age: Int by lazy { 18 }
}

//在被扩展的实例上（第一个参数）添加Flag注解
fun @receiver:Flag Person?.toJson(): String {
    return "{id=$this.id, name=${this?.name}, age=${this?.age}}"
}

Java注解

注解名	作用
`@Volatile`	Java关键字`volatile`
`@Strictfp`	Java关键字`strictfp`
`@JvmName`	改变由kotlin生成的java方法或字段的名称
`@JvmStatic`	用在对象声明或者伴生对象的方法上，把它们暴露成java的静态方法
`@JvmOverload`	指导kotlin编译器为带默认参数值的函数生成多个重载函数
`@JvmField`	将属性暴露成一个没有访问修饰符的公有java字段
`@Synchronized`	为被标记的方法添加线程同步锁

反射

需要引入kotlin-reflect依赖。

ORM框架

import kotlin.reflect.full.declaredMemberProperties
import kotlin.reflect.full.findAnnotation

@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.RUNTIME)
annotation class Table(val name: String = "")

@Target(AnnotationTarget.PROPERTY)
@Retention(AnnotationRetention.RUNTIME)
annotation class ID(val name: String = "")

@Target(AnnotationTarget.PROPERTY)
@Retention(AnnotationRetention.RUNTIME)
annotation class Field(val name: String = "")

interface IDao<T> {
    fun add(): Boolean
    fun delete(): Boolean
    fun update(): Boolean
    fun select(): Boolean
}

abstract class Dao<T> : IDao<T> {
    override fun add(): Boolean {
        val kc = javaClass.kotlin //获取当前实体的类，Dao类的实现对象
        val tbName = kc.findAnnotation<Table>()?.name ?: javaClass.simpleName
        val map = linkedMapOf<String, Any?>().apply {
            kc.declaredMemberProperties.filter {
                it.annotations.isNotEmpty()
            }.forEach {
                it.findAnnotation<ID>()?.let { anno ->
                    put(anno.name, it.get(this@Dao))
                    return@forEach
                }
                it.findAnnotation<Field>()?.let { anno ->
                    put(anno.name, it.get(this@Dao))
                    return@forEach
                }
            }
        }
        val fields = map.keys.joinToString(",")
        val values = map.values.joinToString(",")
        val sql = "insert into $tbName ($fields) values ($values)"
        println(sql) //by JDBC send SQL to DB
        return true
    }

    override fun delete(): Boolean = false
    override fun update(): Boolean = false
    override fun select(): Boolean = false
}

//使用以上框架，用注解标记实体类，让实体类可以和框架进行交互
@Table("书")
class Book(
    @ID("编号") val id: Int,
    @Field("书名") val name: String,
    @Field("作者") var author: String
) : Dao<Book>()

fun main() {
    Book(1, "TAOCP", "knuth").add()
}

`Class`、`KClass`

import kotlin.reflect.KClass
import kotlin.reflect.full.createInstance
import kotlin.reflect.full.primaryConstructor

class Book(val id: Int, val name: String, var author: String)

fun main() {
    //获取类
    var kc: KClass<Book> = Book::class
    //kotlin、java的class转换
    var jc: Class<Book> = Book::class.java
    var kcName = Class.forName("java.lang.Object").kotlin

    //创建对象
    val obj = kcName.createInstance()
    //使用一级构造方法创建对象
    var book = kc.primaryConstructor?.call(1, "书名", "作者名") as Book

    //使用对象获取类
    var c = book::class
    jc = book.javaClass

    //获取构造方法，创建对象
    val constructor = ::Book
    book = constructor(1, "书名", "作者名")

    //获取对象的属性的值
    var name = Book::name.get(book)
    name = book::name.get()

    //修改对象的属性值
    Book::author.set(book, name)
    book::author.set(name)
}

函数类型

将函数作为字段，这个字段的类型为函数类型

Lambda表达式

本质是匿名内部类（只有一个抽象方法的函数式接口）。

为了将表达式当作变量进行传递时使用，避免手动创建多余的类。

//常量gcd是函数类型（(Int, Int) -> Int）
//a, b是形参，形参 -> 语句（表达式）
val gcd: (Int, Int) -> Int = lambda@{ a, b ->
    if (a == 0 || b == 0) return@lambda 0
    var t: Int
    var max: Int = kotlin.math.max(a, b)
    var min: Int = kotlin.math.min(a, b)
    while (max % min != 0) {
        t = max % min
        max = min
        min = t
    }
    return@lambda min
}

fun main() {
    val n = gcd(16, 60)
    println(n)
}

//只有一个参数it的Lambda表达式，有5种写法
val list = listOf(1, 2, 3)
list.forEach({ it -> println(it) })
list.forEach({ println(it) })
list.forEach() { println(it) }
list.forEach { println(it) }
list.forEach(::println)

fun main() {
    //Java基本类型使用Ref.IntRef类型封装
    //其他类型使用Ref.ObjectRef类型封装
    var n = 0
    val inc = {
        n++ //lambda内部访问外部变量
    }
    inc()
    println(n) //1
}

高阶函数

把Lambda表达式当作参数的函数。

//max是类型C的扩展（高阶）函数，返回类型R
//f是类型C的扩展函数，返回类型R
//调用函数f，传入两个I类型的变量，经过外部自定义的语句执行，返回类型R
fun <C, I, R> C.max(i1: I, i2: I, f: C.(a: I, b: I) -> R): R = f(i1, i2)

fun main() {
    //为String类型扩展了max函数
    //传入两个Int进行比较
    //自定义比较的函数当作参数传入
    val n = String.max(12, 15) { a, b -> if (a > b) a else b }
    println(n)
}

内联函数

属性使用const修饰可以成为常量，调用时由于已经初始化赋值，编译器可以直接拷贝值到调用处。

方法如果需要以拷贝的方式替换到调用处，可以使用内联函数。

`inline`

Lambda表达式作为函数的参数时，本质是创建了匿名内部类，然后创建出临时对象，传入形参。

为了避免性能损耗，可以使用内联函数，将代码拷贝到调用处展开，减少方法调用栈的层数（性能损耗忽略不计）。

如果内联函数的方法体太大，会导致字节码文件过大。

fun main() {
    for (i in 1..100) {
        task({ println("准备") }, { println("善后") })
    }
}

inline fun task(preTask: () -> Unit, postTask: () -> Unit): Unit {
    preTask()
    println("执行")
    postTask()
}

编译时代码块替换到调用的位置，不用直接调用task。

...
println("准备")
println("执行")
println("善后")
...

如果不加inline，每次调用task方法，都会创建函数对象（kotlin.jvm.functions.Function0）传入task方法中用完就丢，不适合频繁调用的场景。

//特殊的使用场景（去掉调用方法前边的限定类）
import java.lang.Math as M
public inline fun min(a: Int, b: Int): Int = M.min(a, b)
public inline fun max(a: Int, b: Int): Int = M.max(a, b)
fun main() {
    println(max(1, 2))
}

`noinline`

如果只是将代码块替换到调用的位置，会有意外情况出现。

fun main() {
    val task = task({ println("准备") }, { println("善后") })
    task.invoke()
}

inline fun task(preTask: () -> Unit, noinline postTask: () -> Unit): () -> Unit {
    preTask()
    println("执行")
    postTask()
    //去掉return的"postTask"替换到调用位置后，成为孤立的存在
    //在形参上加上"noinline"，就不参与内联，形参被保留
    return postTask
}

关闭内联优化，使函数类型的形参可以当作对象继续使用。

`crossinline`

fun main() {
    task(
        {
            println("准备")
            //不会中断后续的执行
            return@task
        },
        {
            println("善后")
            //内联后会中断后续的执行
            //添加"crossinline"后，这里不能直接“return”
            /*return*/
            //避免外部调用时错误的使用return
            return@task
        }
    )
    println("结束")
}

inline fun task(preTask: () -> Unit, crossinline postTask: () -> Unit) {
    preTask()
    println("执行")
    postTask()
}

Lambda表达式里不允许使用return，除非是内联函数的参数，这样参数必须加crossinline关键字，使其可以被间接调用。

使用内联函数的注意事项

`reified`

泛型的类型在编译后会被类型擦除。为了避免无法进行正常的类型判断，使用reified标记，函数必须是内联函数。

open class Animal //动物
open class Dog : Animal() //狗
open class Shiba : Dog()//柴犬

//必须使用内联函数，方法体将拷贝到调用处，将T替换为正确的类型，避免被编译时类型擦除
inline fun <reified T> get(list: List<Animal>): T? {
    //类型擦除T后，这里无法判断
    list.forEach { t -> if (t is T) return t }
    return null
}

fun main() {
    val list = listOf<Animal>(Dog(), Shiba())
    val dog = get<Dog?>(list)
    println(dog)
    val shiba = get<Shiba?>(list)
    println(shiba)
}

`this`

class A {
    inner class B {
        fun f1() {
            this@A.ptl("1") //类A
            this@B.ptl("2") //类A$B
        }
        val f2 = { s: String ->
            this.ptl("3") //A$B
        }
    }
    fun f() {
        val b = B()
        b.f1()
        b.f2("123")
    }
}
fun f() {
    val f = fun String.() {
        this.ptl("4") //abc
    }
    f("abc")
}
fun Int.f() {
    this.ptl("5") //1
    this@f.ptl("6") //1
}

fun main() {
    val a = A()
    a.f()
    f()
    1.f()
}
fun Any?.ptl(s: String) {
    println("$s $this")
}

Kotlin与Java互动

Kotlin 中调用 Java - Kotlin 语言中文站 (kotlincn.net)

Kotlin调用Java

关键字冲突

import org.jetbrains.annotations.NotNull;

import java.util.concurrent.Callable;

public class Main {
    @NotNull //使用JSR-305限制null
    public static String when(@NotNull Callable call) throws Exception {
        call.call();
        return "OK";
    }
}

fun main() {
    //when在Java中不是关键字，在Kotlin中是关键字
    //需要使用反引号修饰
    //返回类型可能为null，必须确认这个可能
    val str: String? = Main.`when` { println("Hello Java") }
    println(str)
}

避免使用Any的扩展函数，读取代码时很难分清调用的是哪个方法。

bean规范

public class User {
    private String name;
    private boolean admin;
    private boolean student;

    public void setName(String name) {
        this.name = name;
    }

    public void hasAdmin(boolean admin) {
        this.admin = admin;
    }

    public void setStudent(boolean student) {
        this.student = student;
    }

    public String getName() {
        return name;
    }

    public boolean isAdmin() {
        return admin;
    }

    public boolean getStudent() {
        return student;
    }
}

fun main() {
    val u = User()
    //使用get和set，直接使用属性名进行访问
    u.name = "张三"
    println(u.name)
    //使用is和has，以Getter的方法名为主
    u.hasAdmin(true)
    println(u.isAdmin)
    //使用get和set
    u.student = true
    println(u.student)
    //由于Kotlin规定所有属性都是可读，只有Setter的属性不会出现
}

建议使用getXxx和setXxx的命名规范。

运算符重载

import java.math.BigInteger;

public class Integer {
    private final BigInteger b;

    public Integer(BigInteger b) {
        this.b = b;
    }

    //Kotlin的运算符重载，自动匹配了这个方法
    public Integer plus(Integer other) {
        return new Integer(b.add(other.b));
    }

    @Override
    public String toString() {
        return b.toString(10);
    }

    public String toString(int radix) {
        return b.toString(radix);
    }
}

import java.math.BigInteger

fun main() {
    val a = Integer(BigInteger.ONE)
    val b = Integer(BigInteger.TWO)
    val c = a + b
    println(c)//3
}

函数表达式的传递问题

fun main() {
    val opt = Optional<Runnable>();
    val lambda: () -> Unit = {
        println("Hello")
    }
    //SAM转换的存在，每次都会将Lambda表达式封装为对象，值不一样
    println(lambda.hashCode())
    opt.add(lambda)
    opt.add(lambda)
    opt.add(lambda)
    opt.remove(lambda)
    opt.remove(lambda)
    opt.remove(lambda)
}

import java.util.ArrayList;

public class Optional<T> {
    private final ArrayList<T> list = new ArrayList<>();

    public void add(T t) {
        list.add(t);
        System.out.println("add:" + t.hashCode() + ",size:" + list.size());
    }

    public void remove(T t) {
        list.remove(t);
        System.out.println("remove:" + t.hashCode() + ",size:" + list.size());
    }
}

Java调用Kotlin

类成员

data class Person(
    //var标记后，有get和set方法
    var name: String,
    @JvmField //标记后没有get和set方法，并且public
    var age: Int
)

public class Main {
    public static void main(String[] args) {
        Person p = new Person("张三", 16);
        System.out.println(p.getName());
        p.setName("三张");
        p.age = 17;
        System.out.println(p);
        //调用kotlin时需要注意null
    }
}

单例

object Person{
    fun hello(){
        println("Hello Java")
    }
}

public class Main {
    public static void main(String[] args) {
        Person.INSTANCE.hello();
    }
}

默认参数

object Overloads {
    //加上注解后就拥有了多个重载的方法
    @JvmOverloads
    fun sum(a: Int, b: Int = 0, c: Int = 0): Int {
        return a + b + c
    }
}

public class Main {
    public static void main(String[] args) {
        int r = Overloads.INSTANCE.sum(1, 2, 3);
        System.out.println(r);
        r = Overloads.INSTANCE.sum(5);
        System.out.println(r);
    }
}

包方法

//Package.kt
fun hello() {
    println("Hello")
}

public class Main {
    public static void main(String[] args) {
        PackageKt.hello();
    }
}

扩展方法

//Package.kt
fun String.isEmpty(): Boolean {
    return this == ""
}

public class Main {
    public static void main(String[] args) {
        boolean b = PackageKt.isEmpty("");
        System.out.println(b);
    }
}

`internal`

在Kotlin规则中，被internal修饰后，跨越模块则不能访问。如果被Java调用，修饰Kotlin的类，对于Java处处可用，修饰Kotlin的类成员，无法访问。

协程

Kotlin的协程本质还是线程。不用过多关心线程也可以写出复杂的并发操作。在同一个代码块里进行灵活的线程切换。

使用协程需要引入kotlinx-coroutines依赖。

本质

协程是使用线程封装出的工具包框架。

fun main() = runBlocking {
    val exec = Executors.newSingleThreadScheduledExecutor()
    val task = Runnable { print("|") }
    repeat(10) {
        exec.schedule(task, 1, TimeUnit.SECONDS)
    }

    repeat(10) {
        launch {
            delay(1000L)
            print("-")
        }
    }
}

创建

import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import java.util.concurrent.Executors
import kotlin.concurrent.thread

fun main() = runBlocking {
    //创建线程
    Thread {
        Thread.sleep(5 * 1000L)
        println("${Thread.currentThread()} Thread")
    }.start()
    thread() {
        Thread.sleep(5 * 1000L)
        println("${Thread.currentThread()} thread")
    }
    val exec = Executors.newCachedThreadPool()
    exec.execute {
        Thread.sleep(5 * 1000L)
        println("${Thread.currentThread()} Executors")
    }
    //创建协程
    launch {
        delay(5 * 1000L)
        println("${Thread.currentThread()} 协程")
    }
    println("${Thread.currentThread()} main")
}

非阻塞式

所有的代码本质都是阻塞式的，最基本的一条汇编指令执行时都需要时间，而且执行时不能被其他汇编指令干扰，只是速度快到无法感知的纳秒级别，认为代码是非阻塞式的。如果遇到人可以感受卡顿，这时就认为是阻塞式代码导致的。

借助Kotlin语法优势，写出看似同步却是异步的过程，都在同一个代码块中，而且还不会“卡”当前线程，这就是非阻塞式。只要执行代码时不被耗时的过程卡住，创建个线程，把耗时过程交给另一个线程去做，当前线程就是非阻塞式。

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking

fun main() {
    runBlocking {
        launch(Dispatchers.IO) {
            TODO("保存文件") //将任务切换到后台
        }
        launch(Dispatchers.Main) {
            TODO("更新数据") //将任务切换到前台
        }
        launch(Dispatchers.Default) {
            TODO("更新UI等复杂运算，其他调度器的任务")
        }
    }
}

将不同线程的代码写在同一个源文件中，避免大量的回调嵌套过程，甚至调用的顺序问题。

import kotlinx.coroutines.async
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking

fun main() = runBlocking {
    //async：也是创建协程的方式
    //先获取name和先获取age不影响后续代码逻辑
    var name: String = ""
    async {
        //模拟网络IO阻塞，线程并没有等待
        //而是缓慢的处理（不停的循环判断结束的条件）
        /*api.getName(user)*/delay(5000L)
        name = "张三"
    }
    var age: Int = 0
    async {

        /*api.getAge(user)*/delay(3000L)
        age = 18
    }
    //主线程没有被阻塞，main直接把下面的代码挂起
    //交给上面两个线程执行完各自的过程后恢复，再走完下面的过程
    launch {
        val info = "{name=$name,age=$age}"
        println(info)
    }
    println("任务启动，等待结果")
}

协程的使用场景：当需要指定特定的线程去执行耗时的过程。

fun main() = runBlocking {
    launch(Dispatchers.Main) {
        //withContext：切换线程执行，然后自动切回原先的线程
        val data = withContext(Dispatchers.IO) {
            TODO("读取数据")
        }
        TODO("展示数据")
    }
}

`suspend`

当需要切换线程去执行时，如果将这部分代码封装成函数，需要加suspend关键字，成为挂起函数。

挂起函数中的过程主要是很耗时的计算或者IO操作，这些操作不适合主线程去完成，需要切换线程去执行（挂起的本质），执行完毕后再切回来（被挂起后的恢复）。

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch(Dispatchers.Default) {
        //被调用的挂起函数交给其他指定的线程执行，然后恢复后继续向下执行
        val data = loadData()
        println("${Thread.currentThread()} 展示数据开始") //step:3
        delay(3000L)
        println("${Thread.currentThread()} 展示数据完成") //step:3
    }
    println("${Thread.currentThread()} 任务启动完成") //step:1
}

//挂起函数，线程调用时不会被阻塞，继续往下执行
//线程切换是在withContext代码中，suspend只是起对调用者的提醒作用
//提醒这是个很耗时的过程，在主线程谨慎调用，避免卡顿
suspend fun loadData(): Any = withContext(Dispatchers.IO) {
    println("${Thread.currentThread()} 加载数据开始") //step:2
    delay(3000L)
    println("${Thread.currentThread()} 加载数据完成") //step:2
}

挂起函数必须在协程里面被调用，或者在另一个挂起函数里被调用，这样执行完挂起函数的时候，可以自动把线程切回来。如果在普通线程里调用，执行完就切不回来了（无法恢复被挂起的线程）。

非阻塞式

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking

fun main() {
    runBlocking {
        launch(Dispatchers.IO) {
            TODO("保存文件") //将任务切换到后台
        }
        launch(Dispatchers.Main) {
            TODO("更新数据") //将任务切换到前台
        }
        launch(Dispatchers.Default) {
            TODO("更新UI等复杂运算，其他调度器的任务")
        }
    }
}

将不同线程的代码写在同一个源文件中，避免大量的回调嵌套过程，甚至调用的顺序问题。

import kotlinx.coroutines.async
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking

fun main() = runBlocking {
    //async：也是创建协程的方式
    //先获取name和先获取age不影响后续代码逻辑
    var name: String = ""
    async {
        //模拟网络IO阻塞，线程并没有等待
        //而是缓慢的处理（不停的循环判断结束的条件）
        /*api.getName(user)*/delay(5000L)
        name = "张三"
    }
    var age: Int = 0
    async {

        /*api.getAge(user)*/delay(3000L)
        age = 18
    }
    //主线程没有被阻塞，main直接把下面的代码挂起
    //交给上面两个线程执行完各自的过程后恢复，再走完下面的过程
    launch {
        val info = "{name=$name,age=$age}"
        println(info)
    }
    println("任务启动，等待结果")
}

协程的使用场景：当需要指定特定的线程去执行耗时的过程。

fun main() = runBlocking {
    launch(Dispatchers.Main) {
        //withContext：切换线程执行，然后自动切回原先的线程
        val data = withContext(Dispatchers.IO) {
            TODO("读取数据")
        }
        TODO("展示数据")
    }
}

`suspend`

当需要切换线程去执行时，如果将这部分代码封装成函数，需要加suspend关键字，成为挂起函数。

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch(Dispatchers.Default) {
        //被调用的挂起函数交给其他指定的线程执行，然后恢复后继续向下执行
        val data = loadData()
        println("${Thread.currentThread()} 展示数据开始") //step:3
        delay(3000L)
        println("${Thread.currentThread()} 展示数据完成") //step:3
    }
    println("${Thread.currentThread()} 任务启动完成") //step:1
}

//挂起函数，线程调用时不会被阻塞，继续往下执行
//线程切换是在withContext代码中，suspend只是起对调用者的提醒作用
//提醒这是个很耗时的过程，在主线程谨慎调用，避免卡顿
suspend fun loadData(): Any = withContext(Dispatchers.IO) {
    println("${Thread.currentThread()} 加载数据开始") //step:2
    delay(3000L)
    println("${Thread.currentThread()} 加载数据完成") //step:2
}

如果在挂起函数中没有线程切换（withContext）的操作，这个函数将只能在协程里被调用（必须加suspend关键字）。

同步

@Volatile
var count: Int = 0

@Synchronized
fun count() {
    synchronized(count) {
        count++
    }
}

【Kotlin】从Java转向Kotlin，耐心看完这篇博客就够了。Kotlin快速入门教程分享

导读

build.gradle.kts

目录

基础篇

启动入口

main

注释

方法

数据类型

变量、常量

原始数据类型

整数

浮点

字符

布尔

无符号数字

进制

数组

字符串

数值类型的自动转换

表达式和语句

控制流语句

if

when

for

forEach

do、while

label@

null

Type?

?:

as?

!!

包装类型和基本类型

访问修饰符

修饰类和顶层成员

修饰类的成员

访问权限的传递

数组

创建

常用方法

map

flatMap

fold

associate

distinct

Any、Unit、Nothing

Nothing

集合

不可变集合

可变集合

常用方法

序列

字符串

比较

处理

原始字符串

泛型

型变、约束

方法

可选参数

vararg

*

infix

扩展方法

局部方法

匿名方法

进阶篇

类

构造方法

伴生对象

单例模式

饿汉

懒汉

线程安全的懒汉

双重校验锁

静态内部类模式

匿名内部类对象

init

`if`

`when`

`for`

`forEach`

`do`、`while`

`label@`

`Type?`

`?:`

`as?`

`!!`

`map`

`flatMap`

`fold`

`associate`

`distinct`

`Any`、`Unit`、`Nothing`

`Nothing`

`vararg`

`*`

`infix`

`init`

`inner`

`sealed`

`data class`

`interface`

`field`

`const`

`lateinit`

`by`

`by lazy`

`by Delegates.observable`

`by map`

`in`操作符

`Class`、`KClass`

`inline`

`noinline`

`crossinline`

`reified`

`this`

`internal`