Kotlin

Learning Kotlin: 集合

与数组不同的是可变集合的大小可以动态改变。

List:是一个 有序列表， 可通过索引（下标）访问元素。元素可以在 list 中出现多次、元素可重复。

Set 是 元素唯一的集合。一般来说 set 中元素的顺序并不重要、无序集合、

Map (字典)是一组键值对。键 是唯一的，每个键都刚好映射到一个值，值可以重复。

集合创建方式 示例 说明 是否可变
arrayListOf()
mutableLIstOf()
相同元素类型的列表		 val list= arrayListOf()
val list= mutableLIstOf()		 - 必须指定元素类型 可变
listOf()
相同元素类型的列表		 val list= listOf(1,2,3) - 必须指定元素类型
- 必须指定初始化数据元素		 不可变
arrayMapOf<K,V>()
mutableMapOf<K,V>()
相同元素类型的字典		 val map= arrayMapOf(Pair(“key”, “value”))
val map= mutableMapOf<String, String>()		 - 初始元素使用 Pair 包装 可变
mapOf<>
相同元素类型的字典		 val map= mapOf(Pair(“key”, “value”)) - 元素使用 Pair 包装
- 必须指定初始元素		 不可变
arraySetOf()
mutableSetOf()
相同元素类型的集合		 val set = arraySetOf(1,2,3)
val set = mutableSetOf()		 - 会对元素自动去重 可变
setOf()
相同元素类型的集合		 val set = setOf(1,2,3) - 对元素自动去重
- 必须指定元素类型		 不可变
Kotlin

Learning Kotlin: Lambda 表达式

方法声明：

  • 普通类的方法
  • 静态类的方法
  • companion object 伴生类的方法
1
2
3
fun max(a: Int, b: Int): Int {
    return if (a > b) a else b
}

普通类的方法

1
2
3
4
5
6
7
class Person {
    fun test(){
        println("成员方法")
    }
}

>>> Person().test()

静态类的方法

1
2
3
4
5
6
7
object Util {
    fun test() {
        println("工具类方法")
    }
}

>>> Util.test()

companion object 伴生类的方法

1
2
3
4
5
6
7
8
9
class Person {
    companion object {
        fun test(){
            println("companion function")
        }
    }
}

>>> Person.test()

方法参数

  • 默认参数
  • 具名参数
  • 可变数量的参数

默认参数

方法参数可以有默认值，当省略相应的参数时使用默认值。

1
fun read(offset: Int = 0, start: Int) {}

具名参数

如果一个默认参数在一个无默认值的参数之前，那么无默认值的参数，通过具名参数赋值

1
2
3
 fun read(offset: Int = 0, start: Int) {}

read(start = 1)

如果最后一个参数是方法，那么它既可以作为具名参数在括号内传入，也可以在括号外传入。

1
2
3
4
5
fun read(offset: Int = 0, start: Int, action:() -> Unit){} // action 为方法参数
read(start = 1, action = { println("hello") })
read(start = 1) {
    println("hello")
}

可变数量的参数（Varargs)

1
2
3
4
5
6
7
8
9
10
fun append(vararf str: Str): String {
    val result = StringBuffer()
    for (char in str){
        result.append(char)
    }

    return result.toString()
}

>>> appednd('1', '2', '3')
1
2
val world = charArrayOf('w', 'o', 'r', 'l', 'd')
val result = append('h', 'e', 'l', 'l', 'o', *world)

可变参数的要求：

  • 只有一个参数可以标注为 vararg;
  • 如果 vararg 不是最后一个参数，可以使用具名参数语法，给后面的参数传递值。

Lambda 表达式

隐形参数 it:

  • it 并不是 Kotlin 中的一个关键字（保留字）
  • it 是在当一个高阶方法中 Lambda 表达式的参数只有一个的时候可以使用 it 来使用此参数
  • it 可表示为单个参数的隐式名称，是 Kotlin 语言约定的