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 // 匿名函数

【匿名函数的意义】