关于android:Kotlin-学习笔记之内置类型2

在 Kotlin 学习笔记之内置类型（1）中咱们曾经讲了 Kotlin 内置类型中的 根本类型 、数组和区间，明天咱们来讲 Kotlin 的 汇合框架 和函数。

Kotlin 的汇合有以下特点：

减少了 “ 不可变 ” 汇合框架的接口；
复用了 Java API 的所有实现类型；
提供了丰盛易用的办法，例如 forEach/map/flatMap。

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>>

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)

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]

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"])

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")
}

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

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

Kotlin 中的函数的特点如下：

有本人的类型，在 Kotlin 中十分重要；
能够赋值、传递，并在适合的条件下调用。

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

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

办法能够认为是函数的一种非凡类型；
从模式看，在 类外面 的函数个别称为办法。

例子 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}
}

函数的援用相似 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}
}

晓得了函数的类型和函数的援用之后，咱们就能够定义变量来接管函数，能够类比咱们定义一般变量的模式。

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

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)
}

打印后果如下所示：

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

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

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

// 函数定义
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")

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

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

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

函数在 Kotlin 中算是一个比拟难的知识点了，须要一直的去利用能力真正的把握，明天咱们讲的函数还是一些根底。

本篇博客次要讲了 Kotlin 内置类型中的 汇合框架 和函数。这样 Kotlin 的内置类型算是讲的差不都了，下一篇咱们讲 Kotlin 中的类。

源码已上传至 github，有须要能够间接下载。

关于android:Kotlin-学习笔记之内置类型2

一、前言

二、Kotlin 的汇合框架

2.1、与 Java 比照

2.2、汇合框架的创立

2.3、汇合框架的读写

2.3.1、List 汇合

2.3.2、Map 汇合

2.4、汇合框架的遍历

2.5、Pair(二元祖对象)

2.6、Triple(三元祖对象)

2.7、Kotlin 汇合框架小结

三、Kotlin 的函数

3.1、Kotlin 函数的学习路线

3.2、函数的定义

3.3、函数和办法的区别

3.4、函数的类型

3.5、函数的援用

3.6、定义变量来接管函数

3.7、变长参数

3.8、多返回值

3.9、默认参数

3.10、具名参数

3.11、Kotlin 函数小结

四、小结

五、源码