一：基础要点

//常量定义 val
val arg_a1: Int = 1  
//变量定义var
var arg_a2 = 5  // 系统自动推断变量类型为Int

备注：kotlin 定义变量必须给定初始值，如延迟初始值，需要特殊声明！

空对象处理
//可null对象声明

//类型后面加?表示可为空
var agrs_t: String? = null
//抛出空指针异常
val v1 = agrs_t!!.toInt()
//不做处理返回 null //the safe call operator, written ?.
val v2 = agrs_t?.toLong()
//age为空时返回-1, 非空正常执行
val v3 = agrs_t?.toInt() ?: -1

//显示判断处理
val l: Int = if (b != null) b.length else -1

val b: String? = "Kotlin"  
if (b != null && b.length > 0) {  
    print("String of length ${b.length}")  
} else {  
    print("Empty string")  
}

//安全处理符处理
//the safe call operator, written ?.

val lt = b?.length ?: -1//为空为-1

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

类型判断及转化

//类型判断，如果为String类型，则自动转为String
if (obj is String) {
    print(obj.length)
}
// 非此类型判断，same as !(obj is String)
if (obj !is String) {
    print("Not a String")
}

//可null类型转化
val x: String? = y as String?
//非null转化
//null cannot be cast to String as this type is not nullable,
val x2: String = y as String

equels与引用比较：

两个对象内容比较（Java中的equels）==两个等号代表

两个引用比较使用===三个等号代表

Equality checks: a == b    ，!==
Referential equality: a === b

this关键字引用含义

class A { // implicit label @A
inner class B { // implicit label @B
fun Int.foo() { // implicit label @foo
val a = this@A // A's this
val b = this@B // B's this
val c = this // foo()'s receiver, an Int
val c1 = this@foo // foo()'s receiver, an Int
val funLit = lambda@ fun String.() {
val d = this // funLit's receiver
}
val funLit2 = { s: String ->
// foo()'s receiver, since enclosing lambda expression
// doesn't have any receiver
val d1 = this
}
}
}
}

说明：

1，this默认不加标签，如在类的成员内，标识当前类对象，在成员函数或扩展函数内部则this代表的是接受者类型对象（如变量c,c1代表作用对象Int）

2，this加上@对应类名称代表指定类对象引用，如a,b

函数定义

//返回值函数
fun sum(a: Int, b: Int): Int {
    return a+b
}

//无返回值
fun getHello(){
        //……
 }

//不定参数定义函数
fun varsFor(vararg v:Int){//变长参数 vararg
    for(vt in v){
        print(vt)
    }
}

//函数返回可null类型
fun getStringLength(obj: Any): Int? {
    // `obj` 的类型会被自动转换为 `String`
    if (obj is String && obj.length > 0)
        return obj.length
    return null // 这里的obj仍然是Any类型
}

条件控制：

fun blockIfWhen(a:Int ,b:Int){
val max1 = if (a > b) a else b

var max2: Int  
if (a > b) {  
    max2 = a  
} else {  
    max2 = b  
}

val result = if(a == 1) {  
            "one"  
        }else {  
            "other"  
        }

var x = 0  
//将参数和所有的分支条件顺序比较，直到某个分支满足条件。  
//类似其他语言的 switch 内部else(default)  
when (x) {  
    0, 1 -> println("x == 0 or x == 1")  
    8, 9 -> println("x == 8 or x == 9")  
    else -> println("otherwise")  
}

when (x) {  
    1 -> println("x == 1")  
    2 -> println("x == 2")  
    else -> { // 注意这个块  
        println("x 不是 1 ，也不是 2")  
    }  
}

when (x) {  
    in 0..10 -> println("x 在该区间范围内")  
    else -> println("x 不在该区间范围内")  
}

var tx :Any ?= null  
when (tx) {  
    is Int -> print(tx + 1)  
    is String -> print(tx.length + 1)  
    is IntArray -> print(tx.sum())  
}

//when 也可以用来取代 if-else if链。 如果不提供参数，所有的分支条件都是简单的布尔表达式  
when {  
    x < 5 -> print("x is odd")  
    x < 9 -> print("x is even")  
    else -> print("x is funny")  
}

}

集合：kotlin集合分为mutable(可变类型，元素可修改),read-only（只读类型，没有add,remove,set方法）
1,集合类型包含三种类型：List、Set、Map
2,三种集合类型分别对应MutableList、MutableSet、MutableMap接口

这里以数组为例：

//数组,2种创建 arrayof() ,Array(函数表达式)
//方式一 arrayOf(…)元素初始化
//指定类型
val a = intArrayOf(1, 2, 3)// or arrayOf(1,2,3)
//不限制类型
val a1 = arrayOf(1,"2",true,1.0f,100L)
//方式二 Array(函数or表达式)
val b = Array(10, { i -> (i*2) })//[0,2,4,6,8,]
val b1 = Array(3, { initArray(it) })//[10,11,12…]
//获取元素
// b[1] or b.get(2)
//注：数组内元素为immutable类型，即只读属性

//List 类型，只读类型  
val list1 = listOf(1,2,"3",true) // 不定类型创建  
val list2 = listOf<String>("1","2","3")  // 确定元素的值类型  
val list3 = listOf(a)   // 使用数组创建  
//备注：List一旦创建不可修改，add set remove不能使用

//MutableList 元素可修改  
val mutaList1 = mutableListOf<String>("1","2","3")//通过函数mutableListOf创建  
val mutaList2 = MutableList(5,{ i -> i\*10 })//直接创建并初始化  
val mutaList3 = mutableListOf<String>()//创建空的MutableList,后面可以添加元素  
mutaList1.add("11")  
mutaList1.removeAt(2)  
mutaList1.set(0,"mm")

//Array List,MutableList 内的元素不能为null  
//可以包含null元素的容器需要特殊声明  
//空元素的数组  
var arr = arrayOfNulls<String>(5)  
arr\[0\]="11"  
arr\[1\]=null  
//包含空元素的List  
val nullableList: List<Int?> = listOf(1, 2, null, 4)  
//可含有null元素容器  
val nullableMList:MutableList<String?> = mutableListOf()  
nullableMList.add("11")  
nullableMList.add(null)  

集合常用函数

fun listOperate(){
val items = listOf(1, 2, 3, 4)
items.first() //== 1
items.last() //== 4
val subItems = items.filter { it % 2 == 0 } // returns [2, 4]
var sub2 = items.slice(1..3)
var sub3 =items.filterNot { it>100 }

//高阶函数  
//遍历list  
items.forEach{  

// it= it*2+1
print(it)
}
items.forEachIndexed { index, value -> if (value > 8) println("value of index $index is $value") }
//T->R 集合中的元素通过某个方法转换后的结果存到一个集合
val list11 = items.map { (it - 2+1).toLong() }
val list111 = items.mapIndexed { index, it -> if(index>5) 10 * it }
//合并两个集合
// items.flatMap { listOf(it, it + 1) }

// map：遍历每一个元素
// flatMap：遍历每一个元素，并铺平(展开内部嵌套结构)元素
var list_map = listOf(listOf(10,20),listOf(30,40),listOf(50,60))
var mapList = list_map.map{ element -> element.toString() }
var flatMapList = list_map.flatMap{ element -> element.asIterable() }
// map [[10, 20], [30, 40], [50, 60]]
// flatmap [10, 20, 30, 40, 50, 60]

// filter all 符合条件element  
val list12 = items.filter { mypre(it) }  
//filter 到第一个不符合条件元素返回，后面不再过滤  
val list13 = items.takeWhile { (it%2!=0) }  
//提取前3个元素  
val list14 = items.take(3)  
//提取后3个  
val list15 = items.takeLast(3)  
//去除重复元素  
var list16 = items.distinct()  
//指定key过滤条件  
var list17 = items.distinctBy { it\*101+100 }  

// list1.fold(5,operation = )
//匹配交集元素
var list18 = items.intersect(listOf(2,3,4))
//匹配两个集合内所以不同元素，差集合
var list19 = items.union(listOf(2,3,4))
//返回匹配条件元素
var list21 = items.any { (it in 10..20) }
//返回符合条件元素个数
var list22 = items.count { it >20 }
//给定初始值，指定计算函数对元素累计处理
var list23 = items.fold(10) { total, next -> total + next }
//指定计算函数对元素累计处理
var list24 =items.reduce { total, next -> total - next }

var sumFilterResult : Int = 0  
items.filter { it < 7  }.forEach { sumFilterResult += it }

val rwList = mutableListOf(1, 2, 3)  
// 去除null元素  
rwList.requireNoNulls()  //returns \[1, 2, 3\]  
//检测list内有符合条件元素  
if (rwList.none { it > 6 }) println("No items above 6")  // prints "No items above 6"  
//第一个元素，或为空对象  
val item = rwList.firstOrNull()

//集合分组  
val groupItem:Map<String,List<Int>> = items.groupBy { handleGroup(it) }

val numbers11 = setOf(1, 2, 3)  
println(numbers11.mapNotNull { if ( it == 2) null else it \* 3 })  
println(numbers11.mapIndexedNotNull { idx, value -> if (idx == 0) null else value \* idx })

val colors = listOf("red", "brown", "grey")  
val animals = listOf("fox", "bear", "wolf")  
//集合元素组合压缩  
val zipResult = colors.zip(animals) { color, animal -> "The ${animal.capitalize()} is $color"}  
println(zipResult)

val numbers = listOf("one", "two", "three", "four", "five")  
println(numbers.elementAtOrNull(5))  
println(numbers.elementAtOrElse(5) { index -> "The value for index $index is undefined"})  
println(numbers.last { it.startsWith("f") })  
println(numbers.firstOrNull { it.length > 6 })  
//数据采样  
println(numbers.slice(0..4 step 2))//\[one, three, five\]  
println(numbers.slice(setOf(3, 5, 0)))//\[four, six, one\]  
//安匹配条件分组，转换value  
println(numbers.groupBy { it.first().toUpperCase() })//{O=\[one\], T=\[two, three\], F=\[four, five\]}  
println(numbers.groupBy(keySelector = { it.first() }, valueTransform = { it.toUpperCase() }))//{o=\[ONE\], t=\[TWO, THREE\], f=\[FOUR, FIVE\]}  
//分块处理  
val numbers2 = (0..13).toList()  
println(numbers2.chunked(3))//\[\[0, 1, 2\], \[3, 4, 5\], \[6, 7, 8\], \[9, 10, 11\], \[12, 13\]\]  
println(numbers2.chunked(3) { it.sum() })//per chunk sum  

}

fun handleGroup(v:Int):String{
if(v%2==0) return "even"
else return "odd"
}

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

fun mypre(t:Int): Boolean{
return t%2==0
}

lateinit是否初始化判断

lateinit var mLoginViewModel: LoginViewModel
if(::mLoginViewModel.isInitialized){
return
}

lazy初始化状态判断

val delegateHomePage = lazy{ HomeFragment() }
private val mPageHome by delegateHomePage
if(delegateHomePage.isInitialized()) ts.show(mPageHome)
else{
ts.add(R.id.mainContent,mPageHome)
listPage.add(mPageHome)
}