Kotlin 学习笔记之内置类型（2）

一、前言

在 Kotlin 学习笔记之内置类型（1）中我们已经讲了 Kotlin 内置类型中的基本类型、数组和区间，今天我们来讲 Kotlin 的集合框架和函数。

二、Kotlin 的集合框架

Kotlin 的集合有以下特点：

增加了 "不可变" 集合框架的接口； 复用了 Java API 的所有实现类型； 提供了丰富易用的方法，例如 forEach/map/flatMap。

2.1、与 Java 对比

Kotlin 中的集合分为可变与不可变，与 Java 的比较如下图所示：

Kotlin Java 不可变 List List<T<T>> List<T<T> 可变 List MutableList<T<T>> List<T<T> 不可变 Map Map<K,V> Map<K,V> 可变 Map MutableMap<K, V> Map<K,V> 不可变 Set Set<T<T>> Set<T<T>> 可变 Set MutableSet<T<T>> Set<T<T>>

2.2、集合框架的创建

Java:

List<Integer> intList = new ArrayList<>();

Kotlin:

// List
val intList: List<Int> = listOf(1, 2, 3, 4)
val intList2: MutableList<Int> = mutableListOf(1, 2, 3, 4)

// Map
val map: Map<String, Any> = mapOf("name" to "zs", "age" to 20)
val map2: Map<String, Any> = mutableMapOf("name" to "ls", "age" to 20)

2.3、集合框架的读写

2.3.1、List 集合

Java:

List<String> stringList = new ArrayList<>();
// add
for (int i = 0; i < 10; i++) {
    stringList.add("num: " + i);
}
// remove
for (int i = 0; i < 10; i++) {
    stringList.remove("num: " + i);
}
// set
stringList.set(5, "HelloWorld");
// get
String valueAt5 = stringList.get(5);

Kotlin:

val stringList = ArrayList<String>()
// add
for (i in 0 .. 10){
    // stringList += "num: $i" 运算符重载
    stringList.add("num: $i")
}
// remove
for (i in 0 .. 10){
    // stringList -= "num: $i" 运算符重载
    stringList.remove("num: $i")
}
// set
stringList[5] = "HelloWorld"
// get
val valueAt5 = stringList[5]

2.3.2、Map 集合

Java:

HashMap<String, Integer> hashMap = new HashMap<>();
hashMap.put("Hello", 10);
System.out.println(hashMap.get("Hello"));

Kotlin:

val hashMap = HashMap<String, Int>()
hashMap["Hello"] = 10
println(hashMap["Hello"])

2.4、集合框架的遍历

var mutableList: MutableList<Int> = mutableListOf(1, 2, 3, 4)
// 使用 forEach 
mutableList.forEach {
    println("Mutable List Elements:$it")
}
// 使用 for
for (value in mutableList) {
    print("value:$value")
}

2.5、Pair(二元祖对象)

val pair1 = "Hello" to "Kotlin"
val pair2 = Pair("Hello", "Kotlin")
val first = pair.first
val second = pair.second
val (x, y) = pair

2.6、Triple(三元祖对象)

val triple = Triple("x", 2, 3.0)
val first = triple.first
val second = triple.second
val third = triple.third
val (x, y, z) = triple

2.7、Kotlin 集合框架小结

集合框架小结

三、Kotlin 的函数

Kotlin 中的函数的特点如下：

有自己的类型，在 Kotlin 中非常重要； 可以赋值、传递，并在合适的条件下调用。

3.1、Kotlin 函数的学习路线

Kotlin 函数的学习路线图如下所示，今天我们只学习 Kotlin 函数的基本概念。
函数学习路线

3.2、函数的定义

Kotlin 中函数的定义如下所示，Unit 等价于 Java 中的 Void，如果函数的返回值为 Unit 时，可省略。

3.3、函数和方法的区别

方法可以认为是函数的一种特殊类型； 从形式看，在 类里面的函数一般称为方法。

3.4、函数的类型

例子1：以下这个函数的类型是 () -> Unit 。

fun foo() {}   //函数类型是：() -> Unit

例子2：以下这个函数的类型是 (Int) -> String 。

//函数类型是：(Int) -> String
fun foo(p0: Int): String {
    return ""
}

例子3：以下这个函数的类型是 Foo.(String, Long) -> Any ，也可以写作 (Foo, String, Long) -> Any 。

// Foo.(String, Long) -> Any//第一种写法
// (Foo, String, Long) -> Any//第二种写法
class Foo {
    fun bar(p0: String, p1: Long): Any {
        return 0
    }
}

3.5、函数的引用

函数的引用类似 C 语言中的函数指针，可用于函数传递。

例子1：以下这两个函数的引用都是 ::foo 。

fun foo() {}   //函数引用是：::foo
fun foo(p0: Int): String {...}  // 这个函数的引用也是 ::foo

例子2：以下这个函数的引用是 Foo::bar 。

// 函数引用表示为 Foo::bar
class Foo {
    fun bar(p0: String, p1: Long): Any {
        return 0
    }
}

3.6、定义变量来接收函数

知道了函数的类型和函数的引用之后，我们就可以定义变量来接收函数，可以类比我们定义普通变量的形式。

val name: String = "China"

例子1：定义变量 f

val f: ()->Unit = ::foo  // 可以简化成  val f = ::foo

例子2：定义变量 g

val g: (Int)->String = ::foo  // 可以简化成  val g = ::foo

例子2：定义变量 h

val h: (Foo, String, Long)->Any = Foo::bar  // 可以简化成  val h = Foo::bar

3.7、变长参数

Java 中也是支持变长参数的，具体写法如下所示：

public static void main(String... args) { // String... args 定义变长参数
    System.out.println(Arrays.toString(args));
}

Kotlin 中变长参数是通过 vararg 来表示。

// 可以接受多个 Int
fun multiParameters(vararg ints: Int) {
    println(ints.contentToString())
}

// 调用上述接收变长参数的方法
fun main() {
    multiParameters(1, 2, 3, 4)
}

打印结果如下所示：

3.8、多返回值

变长参数是传递多个不确定个数的参数，但是多返回值返回的个数是确定的，确切的说多返回值就是利用我们前面说到的 Pair 和 Triple 来实现伪多返回值。

fun multiReturnValues(): Triple<Int, Long, Double> {
    return Triple(1, 3L, 4.0)
}

// 伪多返回值
val (a, b, c) = multiReturnValues()

3.9、默认参数

// 函数定义
fun defaultParameter(x: Int, y: String, z: Long) {
    TODO()
}

// 函数调用
defaultParameter(5, "Hello", 0L)

在函数定义中可以使用默认参数，上述的代码就可以变成下面这样：

// 函数定义 声明 z 的默认值是 0L
fun defaultParameter(x: Int, y: String, z: Long = 0L) {
    TODO()
}

// 函数调用  不传参，使用默认值
defaultParameter(5, "Hello")

3.10、具名参数

在上述默认参数代码中，如果 x 也设置了默认参数，这时候不传 x 和 z，只传一个 y，就必须要利用具名参数来传递，否则编译器无法判断传的值应该赋给谁。

// 函数定义 声明 x 的默认值是 5， z 的默认值是 0L
fun defaultParameter(x: Int = 5, y: String, z: Long = 0L) {
    TODO()
}

// 函数调用  形参 y 来显示接收参数
defaultParameter(y = "Hello")