2.3 Kotlin高级

2.3 Kotlin 高级

1. 容器

1.1 分类

• 数组类型
  • array
• 集合类型
  • List
  • Set
  • Map
• 是否可变
  • listOf
  • mutableListOf

1.2 构造

val arr = arrayOf("1",2,3,4)		// 数组

val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape")   // ArrayList<String> 类型
for(fruit in list){
    println(fruit)
}

val mList = mutableListOf("Apple", "Banana", "Orange", "Pear", "Grape")   // ArrayList<String> 类型
mList.add("Watermelon")
for(fruit in mList){
    println(fruit)
}

val map1 = HashMap<String, Int>()
val map2 = HashMap<String, Int>()
for((index, fruit) in list.withIndex()){
    map1.put(fruit, index)      // put 函数
    map2[fruit] = index         // 直接赋值
}
val number = map1["Apple"]      // 读取数据

val map = mapOf("Apple" to 1, "Banana" to 2, "Orange" to 3, "Pear" to 4, "Grape" to 5)
for((fruit, number) in map){
    println("$fruit $number")
}

1.3 集合类型的协变

【暂不学习】

2. Lambda 表达式

1. lambda 表达式基础

1.1 lambda 表达式语法结构

• {参数1: 类型, 参数2: 类型 -> 函数体}
  • lambda 表达式总是被大括号括着
  • 参数在 -> 前
  • 函数体在 -> 后

1.2 3 种具体情况

1. 无参数情况
   • val 变量名 = { 函数体 }
2. 有参数情况
   1. val 变量名 : (类型，类型) -> 返回值类型 = {参数1，参数2 -> 函数体 }
   2. val 变量名 = { 参数1 : 类型，参数2 : 类型 -> 函数体 }
      • 自动推导返回值
3. lambda 表达式作为函数中的参数的时候
   • fun func(a : Int, 参数名 : (参数1 : 类型，参数2 : 类型 ) -> 表达式返回类型) {}

// 1. 简单无参数函数可以直接通过 lambda 省略函数
fun printf() {println("无参数函数")}
val printfLambda = {println("无参数函数")}
printfLambda()

// 2. 有参数情况
fun add1(a : Int, b : Int) : Int {
    return a + b
}
fun add2(a : Int, b : Int) = a + b
val add3 : (Int, Int) -> Int  = {a, b -> a + b}
val add4 =  {a : Int, b : Int -> a + b}

println("${add1(1,2)}, ${add2(1,2)}, ${add3(1,2)}, ${add4(1,2)}")

// 3. lambda 表达式作为函数中的参数
fun sum(num1 : Int, num2 : Int) = num1 + num2
add1(10, sum(3,5))      // 函数作为函数的参数

fun add5(a : Int, b : (num1 : Int, num2 : Int) -> Int) = a + b.invoke(3, 5)  // 函数的参数设定为 lambda 表达式
add5(10, { num1: Int, num2: Int ->  num1 + num2 })      // lambda 表达式作为函数参数

1.3 lambda 表达式简化过程

val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
var maxLengthFruit = list.maxBy({fruit : String -> fruit.length})


// lambda 表达式是函数的最后一个参数时，可以把lambda表达式，即 {函数体} 移动到 () 后面
// maxBy 函数只有lambda表达式作为参数, 省略 ()
// 自动推导省略 string
maxLengthFruit = list.maxBy{fruit -> fruit.length}


// lambda 表达式只有一个参数 (这里只有 fruit) 时，可以用 it 关键字代替
maxLengthFruit = list.maxBy { it.length }

2. lambda 实践

1. it

• it 不是关键字
• lambda 表达式的参数只有一个时，可以用 it 来使用此参数

1. 过滤容器

val newList = list.filter { it.length <=5 }.map{it.uppercase()}  // it 指代每个字符串
newList.forEach { println(it) }

2. 作为函数参数

// f 为一个传入 int 返回 boolean 的函数，其中()表示参数
fun func(n : Int, f : (Int) -> Boolean) : Int{  
	// 调用 f(n)，即将 n 带入到 f 函数中的 it 中，满足条件则返回 n 
    return if (f(n)){n} else 0    
}
println(func(10,{it > 5}))

2. 下划线（__）

• 表示未使用的参数

val map = mapOf("Apple" to 1, "Banana" to 2, "Orange" to 3, "Pear" to 4, "Grape" to 5)
map.forEach { fruit, _ -> println(fruit) }

3. 匿名函数

fun add3(num1: Int, num2: Int) = num1 + num2   
val add4 = fun(num1: Int, num2: Int) = num1 + num2 // 匿名函数

【匿名函数的意义】

3. 高级函数

1. with、run 和 apply

• with：不用记
• run：需要某个对象调用多个成员函数后生成的一个值，用 run 简化代码
• apply：需要一个对象，但是后续还要对该对象需要进行一定操作，可以用 apply 简化代码

val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape")
val builder = StringBuilder()
builder.append("Start eating. \n")

for(fruit in list){
    builder.append(fruit).append("\n")
}

builder.append("Ate all.")
val result1 = builder.toString()

println(result1)


val result2 = with(StringBuilder()){
    append("Start eating. \n")
    for(fruit in list){
        append(fruit).append("\n")
    }
    append("Ate all.")
    toString()
}
println(result2)

val result3 = StringBuilder().run{      // 返回某个值
    append("Start eating. \n")
    for(fruit in list){
        append(fruit).append("\n")
    }
    append("Ate all.")
    toString()
}
println(result3)

val result4 = StringBuilder().apply {   // 无法返回值，而是只能返回自身
    append("Start eating. \n")
    for(fruit in list){
        append(fruit).append("\n")
    }
    append("Ate all.")
}
println(result4.toString())

4. 静态方法

1. 类中的静态方法

• 单例类和伴生对象都不是真正的静态方法
  • 如果不加注解，Java 并不能正确的以静态方式调用这些方法，而 kotlin 可以
• 而加入注解后才是真正的静态方法
  • 此时 Java 和 kotlin 都可以以静态方式调用

fun main() {
    util.doAction2()                            // 调用静态方法

    val u = util()                              // 需要具体对象
    u.doAction1()

    val value = util().run { doAction1() }      // 简化，返回值（这里为 Unit ）
    val obj = util().apply { doAction1() }      // 简化，返回对象
}

class util{
    fun doAction1() {
        println("doAction1")
    }
    companion object {              // 创建伴生类
        @JvmStatic                  // 加入注解后成为真正的静态方法，不加语法也能够正常使用
        fun doAction2() {           // 定义在伴生类的方法
            println("doAction2")
        }
    }
}

2. 顶层静态方法

• 创建一个 Helper.kt 文件，定义顶层方法 doSomething()
  • kotlin 中可以直接调用 doSomething()
  • java 中通过 HelperKt.doSomething() 调用