Kotlin学习笔记(3) -- 那些简便写法

笔记内容来自 扔物线 的 https://kaixue.io/kotlin-basic-3/

构造器

class User(val name: String, val id: String) {
    init {
        ...
    }
}

上述代码可分解（执行顺序为）为：

• 创建一个 User 类
• 添加一个参数为 name 和 id 的主构造器(直接写在类名后面，不需要添加 constructor 关键字，且只能有一个)
• 通过 var 或者 val 将主构造器中的参数声明为类的属性
• 在 init 代码块中添加一些初始化逻辑
• 添加次构造器(次构造器需要添加 constructor 关键字，且用 : 表明与主构造器的依赖关系，可以有多个)

函数简化

1、使用 = 连接返回值

对于如下函数体只有一行代码的函数：

fun area(width: Int, height: Int): Int {
    return width * height
}

可以简写为：

fun area(width: Int, height: Int): Int = width * height

其中由于”类型推断“的特性，返回值类型可省略

2、参数默认值

参数设置默认值时，如果传参的时候不传就使用默认值。可是简化 Java 中方法重载的功能

fun sayHi(name: String = "world") = println("Hi " + name)

调用时：

//调用
sayHi("kaixue.io")
sayHi() // 使用了默认值 "world"

3、命名参数

每一个函数参数都可以作为命名参数

fun sayHi(name: String = "world", age: Int, isStudent: Boolean = true, isFat: Boolean = true, isTall: Boolean = true) {
    ...
}

调用时：

sayHi(name = "wo", age = 21, isStudent = false, isFat = true, isTall = false)

4、嵌套函数

嵌套函数，其他方法不能访问

fun login(user: String, password: String, illegalStr: String) {
    //嵌套函数
    fun validate(value: String) {
        if (value.isEmpty()) {
                                              ?
            throw IllegalArgumentException(illegalStr)
        }
    }
    ...
}

字符串

1、字符串模板

用 $ 加参数或者表达式( 需要用{}包起来 )的方法

val name = "world"
println("Hi $name")
println("Hi ${name.length}")

2、原生字符串

用一对 """ 将字符串括起来,使输出的内容与写的内容完全一致($依然生效)

可以通过trimMargin()去掉每行前面的空格

val name = "world"
val myName = "kotlin"
           ?
val text = """
      Hi $name!
    My name is $myName.\n
""".trimMargin()
println(text)

输出结果：

Hi world!
My name is kotlin.\n

其中对于 trimMargin() 函数：

• | 符号为默认的边界前缀，前面只能有空格，否则不会生效
• 输出时 | 符号以及它前面的空格都会被删除
• 边界前缀还可以使用其他字符，比如 trimMargin("/")，只不过上方的代码使用的是参数默认值的调用方式

数组和集合

1、数组与集合的操作符

操作符	描述
forEach	遍历每一个元素
filter	对每个元素进行过滤操作，符合条件的留下，最终生成一个新的集合
map	遍历每个元素，并执行给定的表达式，最终形成新的集合
flatMap	遍历每个元素，并为每个元素创建新的集合，最终合并到一个集合

例子：

• forEach :

val intArray = intArrayOf(1, 2, 3)
//              ? lambda 表达式，i 表示数组的每个元素
intArray.forEach { i ->
    print(i + " ")
}
// 输出：1 2 3

• filter:

val intArray = intArrayOf(1, 2, 3)
val newList: List = intArray.filter { i ->
    i != 1 // ? 过滤掉数组中等于 1 的元素
}

• map:

//  [1, 2, 3]
//  {2, 3, 4}
val newList: List = intArray.map { i ->
    i + 1 // ? 每个元素加 1
}

• flatMap:

// [1, 2, 3 ]     
// {"2", "a" , "3", "a", "4", "a"}
intArray.flatMap { i ->
    listOf("${i + 1}", "a") // ? 生成新集合
}

2、Range

方法	描述	例子
IntRange	生成一个范围，int型	val range: IntRange = 0..1000(包含1000) /val range: IntRange = 0 until 1000 (不包含1000)
CharRange	生成一个范围，char型	val range :CharArray = charArrayOf('a','b', 'c','1')
LongRange	生成一个范围，long 型	val range :LongArray = longArrayOf(1,2,3)
step	设置步长，默认值为 1	for (i in range step 2) {print("$i, ")}
downTo	递减区间	for (i in 4 downTo 1) { print("$i, ")}

3、Sequence

序列 Sequence 又被称为「惰性集合操作」

val sequence = sequenceOf(1, 2, 3, 4)
val result: List = sequence
    .map { i ->
        println("Map $i")
        i * 2
    }
    .filter { i ->
        println("Filter $i")
        i % 3  == 0
    }
?
println(result.first())

惰性的概念首先就是说在「?」标注之前的代码运行时不会立即执行，它只是定义了一个执行流程，只有 result 被使用到的时候才会执行

println 执行时数据处理流程：

• 取出元素 1 -> map 为 2 -> filter 判断 2 是否能被 3 整除
• 取出元素 2 -> map 为 4 -> filter 判断 4 是否能被 3 整除
  …

惰性指当出现满足条件的第一个元素的时候，Sequence 就不会执行后面的元素遍历了，即跳过了 4 的遍历。而 List 是没有惰性的特性的.

条件控制

1、if/else

if 语句可以作为一个表达式赋值给变量

val max = if (a > b) a else b
val max = if (a > b) {
    println("max:a")
    a // ? 返回 a
} else {
    println("max:b")
    b // ? 返回 b
}

2、when

对应 Java 中的 switch

when (x) {
    ?
    1, 2 -> print("x == 1 or x == 2")
    else -> print("else")
}

在 when 语句中，还可以使用表达式作为分支的判断条件：

when (x) {
   ?
    in 1..10 -> print("x 在区间 1..10 中")
   ?
    in listOf(1,2) -> print("x 在集合中")
   ? // not in
    !in 10..20 -> print("x 不在区间 10..20 中")
    else -> print("不在任何区间上")
}

3、for

val array = intArrayOf(1, 2, 3, 4)
          ?
for (item in array) {
    ...
}
for (i in 0..10) {
    println(i)
}

4、try-catch

try {
    ...
}
catch (e: Exception) {
    ...
}
finally {
    ...
}

try-catch 语句也可以是一个表达式，允许代码块的最后一行作为返回值：

val a: Int? = try { parseInt(input) } catch (e: NumberFormatException) { null }

5、?. 和 ?:

?. 为空安全调用，当对象非空时会执行后面的调用，对象为空时就会返回 null

?: 左侧为空时执行后面的语句

//左侧表达式 str?.length 结果为空，则返回右侧的值 -1
val length: Int = str?.length ?: -1

//验证 user.id 是否为空，为空时 return
val id = user.id ?: return

6、== 和 ===

• == ：可以对基本数据类型以及 String 等类型进行内容比较，相当于 Java 中的 equals
• === ：对引用的内存地址进行比较，相当于 Java 中的 ==