Kotlin学习-基础知识点

一：基础要点

//常量定义 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<E>、MutableSet<E>、MutableMap<K,V>接口

 这里以数组为例：

 //数组,2种创建 arrayof() ,Array(函数表达式)
    //方式一 arrayOf(...)元素初始化
    //指定类型
    val a = intArrayOf(1, 2, 3)// or arrayOf<Int>(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<Int>(2,3,4))
    //匹配两个集合内所以不同元素，差集合
    var list19 = items.union(listOf<Int>(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)
        }