```kotlin
package com.av.bcacc.kotlinpai.api.basic.study
/**
* @description
* @author wlhu
open class KotlinCollection {
fun doHomeWork() {
println("doHomeWork")
}
fun readBook() {
println("readBook")
}
}
fun main() {
println("hello kotlin ...")
println("------------------------【结合list的基本使用001】-------------------")
val fruits = ArrayList<String>()
fruits.add("Apple")
fruits.add("Orange")
fruits.add("Banana")
fruits.add("Pear")
fruits.add("Kiwi")
fruits.add("Cherry")
for (fruit in fruits) {
println(fruit)
}
println("但是这种初始化的方式比较繁琐,kotlin内置了一个listof()函数来简化初始化")
var fruitsNew =
listOf<String>("Apple", "Orange", "Banana", "Pear", "Kiwi", "Cherry", "Watermelon")
for (fruit in fruitsNew) {
println(fruit)
}
println("listof()函数创建的是一个不可变的集合,不可变函数我们无法添加删除修改,可变的集合需要使用mutablelistof()函数")
fruitsNew = mutableListOf("Apple", "Orange", "Banana", "Pear", "Kiwi", "Cherry", "Watermelon")
for (fruit in fruitsNew) {
println(fruit)
}
println("------------------------【结合set的基本使用003 set不可重复】------------------")
var fruitSet =
setOf("Apple", "Orange", "Banana", "Pear", "Kiwi", "Cherry", "Watermelon", "Pear")
for (fruit in fruitSet) {
println(fruit)
}
fruitSet =
mutableSetOf("Apple", "Orange", "Banana", "Pear", "Kiwi", "Cherry", "Watermelon", "Pear")
for (fruit in fruitSet) {
println(fruit)
}
println("------------------------【结合map的基本使用004 Map不可重复】------------------")
println("#############类似java的写法")
var fruitMap = HashMap<String, Int>();
fruitMap.put("Apple", 1)
fruitMap.put("Banana", 2)
fruitMap.put("Orange", 3)
fruitMap.put("WaterMalon", 4)
fruitMap.put("Cherry", 5)
println("apple=${fruitMap.get("Apple")}")
println("#############Kotlin写法")
fruitMap["Pear"] = 100
println("Pear=${fruitMap["Pear"]}")
println("#############Kotlin 更优写法")
val fruitMap2 = mapOf("Apple" to 1, "Banana" to 2, "Orange" to 3)
for ((key, value) in fruitMap2) {
println("key=${key},value=${value}")
}
println("#############Kotlin 可变map写法")
var fruitMap3 = mutableMapOf("Apple" to 1, "Banana" to 2, "Orange" to 3)
fruitMap3["Cherry"] = 456
for ((key, value) in fruitMap3) {
println("key=${key},value=${value}")
}
println("------------------------【集合函数api 004 Lambda】------------------")
var list = listOf("Apple", "Orange", "Banana", "Pear", "Kiwi", "Cherry", "Watermelon")
var maxLengthFruit = ""
for (fruit in list) {
if (fruit.length > maxLengthFruit.length) {
maxLengthFruit = fruit
}
}
println("max length fruit is " + maxLengthFruit)
println("用kotlin集合函数api的优化写法")
println("#######################api maxByOrNull的用法#######################")
val listNew = listOf("Apple", "Orange", "Banana", "Pear", "Kiwi", "Cherry", "Watermelon")
maxLengthFruit = listNew.maxByOrNull { it.length }.toString()
println("max length fruit is " + maxLengthFruit)
println("Lambda 表达式分解写法labda = {参数1:参数类型,参数2:参数类型 ->函数体}")
println("maxByOrNull 传递的是一个lambda的表达式")
val lambda = { fruit: String -> fruit.length }
maxLengthFruit = listNew.maxByOrNull(lambda).toString()
println("原始写法实际上可以一步一步优化成了上面的写法")
println("第一步:不需要定义lambda变量")
maxLengthFruit = listNew.maxByOrNull({ fruit: String -> fruit.length }).toString()
println("第二步:Kotlin规定当Lambda参数是函数的最后一个参数时,可以将lambda表达式移到函数括号的外面")
maxLengthFruit = listNew.maxByOrNull() { fruit: String -> fruit.length }.toString()
println("第三步:如果Lambda参数是函数的唯一一个参数时,可以将函数的括号省略掉")
maxLengthFruit = listNew.maxByOrNull { fruit: String -> fruit.length }.toString()
println("第四步:由于kotlin出色的类型推导能力lambda在大多数情况下都不需要声明参数类型")
maxLengthFruit = listNew.maxByOrNull { fruit -> fruit.length }.toString()
println("第五步:当lambda表达式的参数列表中有一个参数时,也不必要声明参数名,而可以用it来代替")
maxLengthFruit = listNew.maxByOrNull { it.length }.toString()
println("#######################api map函数的用法#######################")
var upperCaseList = listNew.map({ fruit: String -> fruit.uppercase() })
for (fruit in upperCaseList) {
println("fruit:" + fruit)
}
println("#######################api filter函数的用法#######################")
upperCaseList = listNew.filter { it.length > 5 }.map({ fruit: String -> fruit.uppercase() })
for (fruit in upperCaseList) {
println("fruit:" + fruit)
}
println("#######################api any ,all函数的用法#######################")
var anyResult = listNew.any { it.length > 5 }//至少一个
var allReault = listNew.all { it.length > 5 }//所有的
println("anyResult:${anyResult},allReault:${allReault}")
println("#######################【集合函数api 005 thread Lambda】 的优化写法######################")
println("kotlin中舍弃了new 那创建匿名内部类就用object关键字")
Thread(object : Runnable {
override fun run() {
println("我是thread优化前的写法")
}
}).start()
Thread {
println("我是thread优化后的写法")
}.start()
println("原始写法实际上可以一步一步优化成了lambda的写法")
println("第一步:Runnable类中只有一个待实现的方法,即使这里没有显示地重写run()方法,Kotlin也能自动明白里面的run")
Thread(Runnable {}).start()
println("第二步:如果java方法列表中有且仅有一个java单抽象类方法接口参数,我们可以将接口省略")
Thread({}).start()
println("第三步:如果Lambda参数是函数的唯一一个参数时,可以将函数的括号省略掉,并可以把lambda表达式移动到外面")
Thread {
println("我就是最终的效果")
}.start()
println("#######################【集合函数 006 空指针检测】######################")
println("kotlin 默认所有参数和变量都不可为空")
//doStudy(null)
println("kotlin 如果需要为空需要使用?:Int?表示可以为空的整型,String?表示不可以为空的字符串")
doStudy(null)
println("kotlin 使用?.的形式判断不为空")
doStudy1(null)
println("kotlin 使用let函数判断不为空的执行,即使对象为全局变量依然可以正常工作,if则不可以")
doStudy2(null)
println("kotlin 符号?:的作用:如果左边表达式不为空就返回左边表达式的结果,否则就返回右边表达式的结果")
println("1.text length = ${getTextLength("hello kotlin")}")
println("2.text length = ${getTextLength1("hello kotlin")}")
println("3.text length = ${getTextLength2("hello kotlin")}")
}
fun doStudy(mKotlinCollection: KotlinCollection?) {
if (mKotlinCollection != null) {
mKotlinCollection.doHomeWork()
mKotlinCollection.readBook()
}
}
fun doStudy1(mKotlinCollection: KotlinCollection?) {
mKotlinCollection?.doHomeWork()
mKotlinCollection?.readBook()
}
fun doStudy2(mKotlinCollection: KotlinCollection?) {
mKotlinCollection?.let {
mKotlinCollection.doHomeWork()
mKotlinCollection.readBook()
}
}
//原始判断
fun getTextLength(text: String?): Int {
if (text != null) {
return text.length
}
return 0
}
//使用?:的优化写法1
fun getTextLength1(text: String?): Int {
return text?.length ?: 0;
}
//使用?:的优化写法2
fun getTextLength2(text: String?) = text?.length ?: 0;
```kotlin
hello kotlin ...
------------------------【结合list的基本使用001】-------------------
Apple
Orange
Banana
Pear
Kiwi
Cherry
但是这种初始化的方式比较繁琐,kotlin内置了一个listof()函数来简化初始化
Apple
Orange
Banana
Pear
Kiwi
Cherry
Watermelon
listof()函数创建的是一个不可变的集合,不可变函数我们无法添加删除修改,可变的集合需要使用mutablelistof()函数
Apple
Orange
Banana
Pear
Kiwi
Cherry
Watermelon
------------------------【结合set的基本使用003 set不可重复】------------------
Apple
Orange
Banana
Pear
Kiwi
Cherry
Watermelon
Apple
Orange
Banana
Pear
Kiwi
Cherry
Watermelon
------------------------【结合map的基本使用004 Map不可重复】------------------
#############类似java的写法
apple=1
#############Kotlin写法
Pear=100
#############Kotlin 更优写法
key=Apple,value=1
key=Banana,value=2
key=Orange,value=3
#############Kotlin 可变map写法
key=Apple,value=1
key=Banana,value=2
key=Orange,value=3
key=Cherry,value=456
------------------------【集合函数api 004 Lambda】------------------
max length fruit is Watermelon
用kotlin集合函数api的优化写法
#######################api maxByOrNull的用法#######################
max length fruit is Watermelon
Lambda 表达式分解写法labda = {参数1:参数类型,参数2:参数类型 ->函数体}
maxByOrNull 传递的是一个lambda的表达式
原始写法实际上可以一步一步优化成了上面的写法
第一步:不需要定义lambda变量
第二步:Kotlin规定当Lambda参数是函数的最后一个参数时,可以将lambda表达式移到函数括号的外面
第三步:如果Lambda参数是函数的唯一一个参数时,可以将函数的括号省略掉
第四步:由于kotlin出色的类型推导能力lambda在大多数情况下都不需要声明参数类型
第五步:当lambda表达式的参数列表中有一个参数时,也不必要声明参数名,而可以用it来代替
#######################api map函数的用法#######################
fruit:APPLE
fruit:ORANGE
fruit:BANANA
fruit:PEAR
fruit:KIWI
fruit:CHERRY
fruit:WATERMELON
#######################api filter函数的用法#######################
fruit:ORANGE
fruit:BANANA
fruit:CHERRY
fruit:WATERMELON
#######################api any ,all函数的用法#######################
anyResult:true,allReault:false
#######################【集合函数api 005 thread Lambda】 的优化写法######################
kotlin中舍弃了new 那创建匿名内部类就用object关键字
我是thread优化前的写法
原始写法实际上可以一步一步优化成了lambda的写法
第一步:Runnable类中只有一个待实现的方法,即使这里没有显示地重写run()方法,Kotlin也能自动明白里面的run
我是thread优化后的写法
第二步:如果java方法列表中有且仅有一个java单抽象类方法接口参数,我们可以将接口省略
第三步:如果Lambda参数是函数的唯一一个参数时,可以将函数的括号省略掉,并可以把lambda表达式移动到外面
#######################【集合函数 006 空指针检测】######################
kotlin 默认所有参数和变量都不可为空
kotlin 如果需要为空需要使用?:Int?表示可以为空的整型,String?表示不可以为空的字符串
kotlin 使用?.的形式判断不为空
kotlin 使用let函数判断不为空的执行,即使对象为全局变量依然可以正常工作,if则不可以
kotlin 符号?:的作用:如果左边表达式不为空就返回左边表达式的结果,否则就返回右边表达式的结果
我就是最终的效果
1.text length = 12
2.text length = 12
3.text length = 12