android

Kotlin语法

Posted by アライさん on 2019年11月04日

表达式函数体

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

顶层函数

直接把方法写到kt文件中而不是类中

1
2
3
4
5
6
7
// 文件名 join.kt
package strings
fun joinToString() : String {...}

/* Java */
import strings.JoinKt;
JoinKt.joinToSting(....)

Lambda

以->分割，左边是参数，右边是函数体

成员引用::

1
2
3
val people = listOf(User(1, "A", "B"), User(2, "C", "D"))
//以User中的id为值，取最大值  
people.maxBy(User::id)

扩展函数

1
2
3
4
fun String.addKey(key:String):String{
        return this+key
}
"你好".addKey("我是key")

局部函数

函数内部定义的函数。局部函数可以访问上层函数的参数和变量

1
2
3
4
5
6
7
8
9
10
11
12
fun saveUser(user:User){

    fun validate(value:String){
        if(value.isEmpty()){
            throw IllegalArgumentException("Name is Empty")
        }
    }

    validate(user.name)
    //没有throw Exception，则执行操作
    //do somethings
}

get set

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
var connectState: NetworkInfo.DetailedState = NetworkInfo.DetailedState.IDLE
    get() = field
    set(value) {
        field = value
        if (value == NetworkInfo.DetailedState.CONNECTING ||
            value == NetworkInfo.DetailedState.AUTHENTICATING ||
            value == NetworkInfo.DetailedState.OBTAINING_IPADDR ||
            value == NetworkInfo.DetailedState.CONNECTED
        ) {
            sortByKey = 2
        } else if (isSaved()) {
            sortByKey = 1
        } else {
            sortByKey = 0
        }
    }

Application单例

1
2
3
4
5
6
7
8
9
10
class MyApplication : Application() {
    companion object {
        lateinit var instance: MyApplication
            private set
    }
    override fun onCreate() {
        super.onCreate()
        instance = this
    }
}

let:用it代替自身

1
2
3
4
5
6
7
8
9
10
activity?.let {
    //activity非null运行。it等价为activity
    it.tvName = "Alois"
 }
val value = "text".let{
    //输出text，value赋值为3
    Log.d("tag",it)
    3
}


apply:把对象本身传入

1
2
3
4
val thread = Thread(Runnable{}).apply{ start() }
//等价于
val thread = Thread(Runnable{})
thread.start()

run:返回最后一行的值或者return

1
2
3
4
5
val a = run{
    Log.d("tag","run")
     3//等价为return@run 3
}
//最终a为3

also:返回自己，it也为自己

1
2
3
4
val a = "text".also {
    Log.d("tag","it=$it")//it为text
}
Log.d("tag","a=$a")//a为text

with:this为参数，最后一行或return返回

1
2
3
4
val a = with("text"){
  Log.d("tag","this:$this")
}
Log.d("tag","a:$a")

when替换if：

1
2
3
4
val a = true
when{
   a -> Log.d("tag","when")
}

继承构造函数

1
2
3
4
5
class AlarmDBHelper constructor(
    context: Context,
    databaseName: String = "alarm_db",
    databaseVersion: Int = 1
) : SQLiteOpenHelper(context, databaseName, null, databaseVersion) {}

by lazy

1
2
3
4
//by lazy可以实现，val在第一次使用时才初始化   
    private val netClientFactory by lazy {
        NetClientFactory.getService(ApiInterface::class.java)
    }

sortBy字符串排序

1
2
3
4
5
6
7
8
"89238904271".toCharArray().sorted().joinToString("")
modelList.sortBy { it.sortNumber }//modelList即可变成有序状态

//先根据sortByKey从小到大排序，sortByKey相同则使用levelSort从小到大
modelList.sortedWith(compareBy({ it.sortByKey }, { it.levelSort }))
//先根据sortByKey从大到小排序，sortByKey相同则使用levelSort从大到小
modelList.sortWith(compareByDescending<ScanResultModel> { it.sortByKey }
            .thenByDescending { it.levelSort })

map{}与flatMap{}

1
2
3
4
5
6
7
8
9
10
11
12
13
val string0 = arrayListOf("Geeks", "GFG", "GeeksforGeeks", "gfg")
val string1 = arrayListOf("Geeks", "GFG", "GeeksforGeeks", "gfg")
val string2 = arrayListOf("Geeks", "GFG", "GeeksforGeeks", "gfg")

val strings = arrayListOf(string0,string1,string2)
//flatMap可以把多个list，按顺序合成一个list。
//比如可以把一个String的list，按顺序合成一个Char的list
val result = strings.flatMap { it.toList() }
//map可以遍历list
//等价于strings.flatMap{}.map{}
result.map {
    LogUtils.d(it)
}

take & slice截取

1
2
3
4
5
val test = listOf(3, 2, 4, 6, 7, 1)
// 获取前3个元素的新切片
test.take(3)
// 获取指定index组成的新切片
test.slice(IntRange(2, 4))

all & any & count & find

1
2
3
4
5
6
7
8
9
10
val test = listOf(1, 3, 5, 7, 9)
// all判断是否全部符合lambda表达式的条件
println("是否全部符合>10 ${test.all { it > 10 }}")
// any判断是否存在有符合lambda表达式的条件的数据
println("是否存在>8 ${test.any { it > 8 }}")
// count获取符合lambda表达式条件的数据个数
println("大于5的个数 ${test.count { it > 5 }}")
// find获取符合lambda表达式条件的第一个数据
println("第一个大于5 ${test.find { it > 5 }}")
println("最后一个大于5 ${test.findLast { it > 5 }}")



Tags
android