1.函数简化
fun plus(args1:Int,args2:Int):Int {
return args1+args2
}
fun plus(args1:Int,args2:Int):Int = args1+args2
2.命名参数,参数默认值,位置参数
/**
* 命名参数,位置参数调用的时候有个主意事项,位置参数必须放在命名参数的前面
* 如果写成(name="huhu",20,"hehe"),那么后两个参数就会报错
*Mixing named and positioned arguments is not allowed
*/
namedParams("huhu", age = 20, id = "hehe")
3.嵌套函数
可以在函数内部声明一个函数,这个函数不可以被外部函数之外的地方使用
4.字符串模板和原生字符串
val name = "world"
// 👇 用 '$' 符号加参数的方式
println("Hi $name")
println("Hi ${args.length})
fun testString() {
var strings = """
wo hsi yige zho fa.?jn
dkjfkajdkf adfa
jdkfjak
"""
println(strings)
}
5.数组和集合的操作符
forEach():遍历每一个元素
fun testArraySysmol() {
var strArray1 = intArrayOf(1,2,3,4)
strArray1.forEach { i -> println(i) }
}
filter:对每个元素进行过滤操作,如果条件满足则留下,不满足则剔除,返回一个集合类型的数据
fun testArraySysmol() {
var strArray1 = intArrayOf(1,2,3,4)
//注意:这里数组类型使用.filter()之后,返回值为List类型
val filter: List<Int> = strArray1.filter { i -> i != 1 }
filter.forEach { i -> println(i) }
}
map:遍历每一个元素并执行给定的表达式,返回一个List集合
fun testArraySysmol() {
var strArray1 = intArrayOf(1,2,3,4)
var mapResult:List<Int> = strArray1.map { i -> i+2 }
mapResult.forEach { i -> println(i) }
}
flatMap:遍历每一个元素,并未每个元素创建一个新的集合,最后合并成为一个集合
fun testArraySysmol() {
var strArray1 = intArrayOf(1,2,3,4)
var flatMapResult:List<String> = strArray1.flatMap { i -> listOf("${i+2}","a") }
flatMapResult.forEach { i -> print(i) }
}
Range:区间,范围
fun rangeTest() {
//表示1到1000,包括1000
val rangeNum:IntRange = 1..1000
//表示1到1000,但不包括1000
val rangeNum:IntRange = 1 until 1000
for (i in rangeNum) println(i)
//step : 设置步长 1,3,5,7,9
for (i in rangeNum step 2) println(i)
//downTo:递减区间
for (i in 4 downTo 1) println(i)
}
Sequence:惰性加载集合
- 一旦满足遍历退出的条件，就可以省略后续不必要的遍历过程。
- 像 List 这种实现 Iterable 接口的集合类，每调用一次函数就会生成一个新的 Iterable，下一个函数再基于新的 Iterable 执行，每次函数调用产生的临时 Iterable 会导致额外的内存消耗，而 Sequence 在整个流程中只有一个。
fun listTest() {
val listResult = listOf<Int>(1,2,3,4)
var result2 = listResult.map { i->
print("Map $i ,")
i*2
}
.filter { i ->
print("Filter $i ,")
i%3 == 0
}
//list不管下面执行不执行,上面的代码都会立即执行
println(result2.first())
}
fun squenceTest() {
var squenceResult = sequenceOf(1,2,3,4)
var result2:Sequence<Int> = squenceResult.map { i ->
print("Map $i ,")
i*2
}
.filter { i ->
print("Filter $i ,")
i%3 == 0
}
//在下面的这句println执行前,上面的print()是不会调用的,也就是说sequence只是指定流程,而并不立即执行
println(result2.first())
}
条件控制
fun whenTest(num:Int) {
when(num) {
// 也可以这样写
// 0,1 -> println("我是0,或者1")
0 -> println("我是0")
1 -> println("我是1")
2 -> println("我是2")
else -> print("我是特殊情况")
}
}
- in
fun whenTest(num:Int) {
when(num) {
in 0..10 -> println("我在里面")
in listOf<Int>(11,22,33,44,55) -> println("我在集合中")
else -> print("我是特殊情况")
}
}
- is :进行特定类型的检测
- when后面省略参数,每一个分支条件都可以是一个布尔表达式：
when {
str1.contains("a") -> print("字符串 str1 包含 a")
str2.length == 3 -> print("字符串 str2 的长度为 3")
}
For
fun testFor() {
//循环集合
var listData = listOf<String>("mike","marry","jonse")
for (item in listData) println(item)
//循环一个100次呢
for (item in 1..100) print("$item ,")
}
try..catch
fun testTryCatch() {
try {
val i = 5
val j = 0
i/j
}catch (e:Exception) {
println("我异常了")
}finally {
println("我是必须要执行的")
}
}
- 和java的亮点不同:
1.java中如果抛出一个异常,那么调用的地方一定要进行处理,否则报错
kotlin中是不会报错的,但在运行时可能报错
2.Kotlin 中 try-catch 语句也可以是一个表达式，允许代码块的最后一行作为返回值：
val a: Int? = try { parseInt(input) } catch (e: NumberFormatException) { null }
?.和?:
var str: String? = null
fun testnullsafe() {
var length:Int? = str?.length
var length2:Int = str?.length?:-1
}
第二种用法:
fun validate(user: User) {
val id = user.id ?: return // 👈 验证 user.id 是否为空，为空时 return
}
== 与 ===
- == ：可以对基本数据类型以及 String 等类型进行内容比较，相当于 Java 中的 equals
- === ：对引用的内存地址进行比较，相当于 Java 中的 ==
