Kotlin关键字快速查找

关键字	注释
constructor	构造函数
Any	Kotlin Any简介Any类型是Kotlin所有非空类型的超类型（非空类的根）,包含像Int这样的基本数据类型
open	在Kotlin开发中类和方法默认不允许被继承和重写，等同于Java中用 final 修饰类和方法。如果在Kotlin 中类和方法想被继承和重写，需添加open 关键字修饰。
final	表示类不可继承，默认属性
var	var是一个可变变量，这是一个可以通过重新分配来更改为另一个值的变量。这种声明变量的方式和Java中声明变量的方式一样。
val	val是一个只读变量，这种声明变量的方式相当于java中的final变量。一个val创建的时候必须初始化，因为以后不能被改变。
const	表示静态属性，在java中并不会生成get set
set(value) {field = value}	重写该属性的get和set
::	双冒号，表示调用当前 Class 的内部方法 MainActivity::class.java
companion	类内部的对象声明可以用 companion 关键字标记，这样它就与外部类关联在一起，我们就可以直接通过外部类访问到对象的内部元素
by	委托，可用于类委托和属性委托
Lazy	延迟属性，第一次调用会有过程，后面就是只有纯结果。lazy 应用于单例模式(if-null-then-init-else-return)，而且当且仅当变量被第一次调用的时候，委托方法才会执行。lazy 只用于常量 val
lateinit	告诉编译器我没法第一时间就初始化，但我肯定会在使用它之前完成初始化的。lateinit 只用于变量 var
Not Null	委托不能为空，如果使用的时候为空，则会抛出异常
by Delegates.observable	实现观察者模式，观察属性的变化
by map	把属性储存在映射map中
类型?	表示当前xx对象可以为空
notNull(a,b)	notNull(a,b){ xxxx } 同时判断多个变量为空时的逻辑处理
？:	foo?:bar，如果foo不为null则返回foo,如果为null则返回bar
xx?.toLong()?: 0	xx如果为null就返回0，否则返回Long类型数值
!!	判断这个参数如果是空参数,就抛出异常
?.	与java相同:if(a!=null){ a.run();}
object.let{}	在函数体内使用it替代object对象访问公有的属性和方法
object.?.let	与java相同:if(a!=null){ a.run();}
object?.let {//非空时怎么写} ?: let {//为空又怎么写}	判断object非空和为空的逻辑处理
object.apply{}	内联扩展,返回object自身
companion object	伴身对象,kotlin没有静态static的说法，随之代替的是它，具体相关使用Kotlin 对象表达式和对象声明 - (jianshu.com)
use	代替了java的try-catch-finally
arrayOf	数组
xx in xx	循环
for (index in 1..100)	输出1，2，3，4...100
for (position in 100 downTo 0)	倒序排序，输出100，99，98，97...0
vararg	可变参数，就是类似java的Integer... rest，kotlin语句就是vararg rest: Integer，记得使用rest的时候要在前面加个*,即是 *rest
annotation	注解类
arrayOfNulls	可以用于创建一个指定大小的、所有元素都为空的数组
@Volatile	类似@Synchronized，但是性能优于它，使用volatile必须具备以下2个条件，对变量的写操作不依赖于当前值（比如递增）、该变量没有包含在具有其他变量的不变式中
check(boolean){}	如果boolean为false，抛出异常IllegalStateException
require(boolean){}	如果boolean为false，抛出异常IllegalArgumentException
assert(boolean){}	如果boolean为false，抛出异常AssertionError
sealed	简单来理解就是他是一个拓展版的枚举(enum)，不同之处在于枚举的实例是唯一的，而密封类可以有很多实例，它们可以有不同的状态
suspend	是协程中很重要的关键字，它用来修饰函数，表示此函数是一个会挂起的函数，并且 挂起函数只有在协程中使用或者被另一个挂起函数调用，可以暂停和进行恢复

注解

关键字	注释
@JvmStatic	如果它是函数，则需要从此元素生成额外的静态方法。如果此元素是属性，则应生成额外的静态 getter / setter 方法。

等价代码

作用	java	kotlin
实例化	XX xx = new XX()	var xx = XX()
实例默认	XX xx	var xx : XX
静态变量	private static final String EXTRA_TITLE = "extra_title"	private val EXTRA_TITLE = "extra_title"
创建数组	new String[]{MediaStore.Images.ImageColumns.DATA}	arrayOf(MediaStore.Images.ImageColumns.DATA)
数组类型	int[]	IntArray
类型判断	!(xx instanceof xx)	!is
switch	switch(xxx) {case A:break;case B: break;default:break;}	when(xxx) { A -> B-> else -> {} }
switch	不根据某个变量判断	when {isImage() -> {} isVideo() -> else ->{} }
强制转换	(类型)xxxxx代码	xxxx代码 as 类型
强制转换2	(类型)xxxxx代码	xxx.toLong()
或运算	a |= b	a = a or b
internal 适用于内部类使用，如果内部类仅仅使用private，就只能内部类自己访问		internal fun xx()
internal 限制了跨 module 的方法的使用	static final class	internal class
internal inner 类似java的内部类，加上inner才可以使用外部变量	class xx	internal inner class
接口	public interface xxx	interface xxx
字符串格式化，目前Kotlin还没有，只能用java的	String.format	java.lang.String.format
范围判断	i>=min && i <=max	i in min..max
范围判断2	i>=min && i	i in min until max
for数组循环	for (int i = 0; i < max; i++)	i in 0 until max
for对象循环	for (XXXX item : list)	for (item in list)
for相反顺序循环	for (int i = list.size() - 1; i >= 0; i--)	for (i in list.indices.reversed()) 或 for (i in (0 until childCount).reversed())
在方法参数里面new对象	ThreadUtils.executeByIo(new ThreadUtils.BaseSimpleBaseTask(){})	ThreadUtils.executeByIo(object : BaseSimpleBaseTask(){})
调用类自身	XXXXX.this	this@XXXXX
三次元运算符	xx == null ? a : b	xx?.toLong() ?: -1
内部类	class myWebChromeClient : WebChromeClient() {	private val myWebChromeClient: WebChromeClient = object : WebChromeClient() {

创建数组的几种方法

val asc1 = arrayOf(1, 2, 4)

val asc2 = arrayOfNulls(3)
asc2[0] = 1
asc2[1] = 2
asc2[2] = 4

val asc3 = Array(3){ i -> i + 1 }

val asc4 = intArrayOf(1, 2, 4)

val asc5 = IntArray(1){ i -> i + 1}

集合

fun main() {
    var mutableMap = mutableMapOf()
    mutableMap[1] = "a"
    mutableMap[0] = "b"
    mutableMap[1] = "c"
    println(mutableMap)

    var mutableList = mutableListOf()
    mutableList.add(1)
    mutableList.add(0)
    mutableList.add(1)
    println(mutableList)

    var mutableSet = mutableSetOf()
    mutableSet.add(1)
    mutableSet.add(0)
    mutableSet.add(1)
    println(mutableSet)
}

输出

{1=c, 0=b}
[1, 0, 1]
[1, 0]