一、前言
在 给 Android 开发者的 Kotlin 教程（一）中我们主要就是简单的讲了一下 Kotlin 与 Java 的比较。这一节我们来讲一下 Kotlin 的必备基础，分别是 Kotlin 中的基本数据类型、数组以及集合这三大知识点。
二、认识 Kotlin 基本类型
Kotlin 的基本数值类型包括 Byte、Short、Int、Long、Float、Double 等。不同于 Java 的是，字符不属于数值类型，是一个独立的数据类型。
对于整数，存在四种具有不同大小和值范围的类型
| 类型 | 位宽 | 最小值 | 最大值 |
|---|---|---|---|
| Byte | 8 | -128 | 127 |
| Short | 16 | -32768 | 32767 |
| Int | 32 | -2^31 | 2^31 - 1 |
| Long | 64 | -2^63 | 2^63 - 1 |
对于浮点数，Kotlin 提供了 Float 和 Double 类型
| 类型 | 位宽 |
|---|---|
| Float | 32 |
| Double | 64 |
2.1、基本类型代码演练
Kotlin 定义变量的关键字只有 val 和 var 两种。但是在定义 Int 类型变量的时候我们并不需要 val Int2: Int = 2 这样写，直接 val Int2 = 2 就可以了。那是因为 kotlin 能为我们自动推导变量的类型而不需要我们指定。
利用下面的 printType() 方法我们就可以查看每个变量具体的类型了。
fun main() {
println("---main---")
baseType()
}
// Kotlin 基本类型代码演示
fun baseType() {
val num1 = -1.67 // double
val num2 = 2 // Int
val num3 = 2f // Float
val int1 = 3 // Int
println("num1:$num1 num2:$num2 num3:$num3 int1:$int1")
println(abs(num1))
println(num1.toInt()) // 转换成Int
printType(num1)
printType(num2)
printType(num3)
printType(int1)
}
fun printType(param: Any) {
println("$param is ${
param::class.simpleName} type")
}
代码运行结果如下所示：
三、走进 Kotlin 的数组
数组在 Kotlin 中使用 Array 类来表示，它定义了 get 与 set 方法以及 size 属性，以及一些其他有用的成员方法，具体源码如下所示：
public class Array<T> {
public inline constructor(size: Int, init: (Int) -> T)
public operator fun get(index: Int): T
public operator fun set(index: Int, value: T): Unit
public val size: Int
public operator fun iterator(): Iterator<T>
}
3.1、Kotlin 数组的创建技巧
3.1.1、使用 arrayOf() 方法创建数组
我们可以使用库方法 arrayOf() 来创建一个数组并传递元素值给它，例如 arrayOf(1, 2, 3) 创建了 array [1, 2, 3]。
3.1.2 、使用 arrayOfNulls() 方法创建数组
也可以使用库方法 arrayOfNulls() 创建一个指定大小的、所有元素都为空的数组。
3.1.3 、创建有初始值的数组
// 创建一个 Array<String> 初始化为 ["0", "1", "4", "9", "16"]
val asc = Array(5) {
i -> (i * i).toString() }
asc.forEach {
println(it) }
Kotlin 不让我们把 Array 赋值给 Array，以防止可能的运行时失败。
3.1.4 、原生类型数组
Kotlin 也有无装箱开销的专门的类来表示原生类型数组: IntArray、ByteArray、 ShortArray 等等。这些类与 Array 并没有继承关系，但是它们有同样的方法属性集。它们也都有相应的工厂方法:
//通过intArrayOf、floatArrayOf、doubleArrayOf等创建数组
val x: IntArray = intArrayOf(1, 2, 3)
println("x[1] + x[2] = ${
x[1] + x[2]}")
// 大小为 5、值为 [0, 0, 0, 0, 0] 的整型数组
val arr = IntArray(5)
// 例如：用常量初始化数组中的值
// 大小为 5、值为 [42, 42, 42, 42, 42] 的整型数组
val arr = IntArray(5) {
42 }
// 例如：使用 lambda 表达式初始化数组中的值
// 大小为 5、值为 [0, 1, 2, 3, 4] 的整型数组（值初始化为其索引值）
var arr = IntArray(5) {
it * 1 }
3.2、Kotlin 数组的遍历技巧
3.2.1、数组遍历
for (item in array) {
println(item)
}
3.2.2、带索引遍历数组
for (i in array.indices) {
println(i.toString() + "->" + array[i])
}
3.2.3、遍历元素（带索引）
for ((index, item) in array.withIndex()) {
println("$index->$item")
}
3.2.4、forEach 遍历数组
array.forEach {
println(it) }
3.2.5、forEach 增强版
array.forEachIndexed {
index, item ->
println("$index：$item")
}
3.3、数组代码演练
fun main() {
println("---main---")
arrayType()
}
/**
* 数组
*/
fun arrayType() {
// arrayOf
val array: Array<Int> = arrayOf(1, 2, 3)
// ArrayOfNulls
val array1 = arrayOfNulls<Int>(3)
array1[0] = 4
array1[1] = 5
array1[2] = 6
// 通过Array的构造函数
val array2 = Array(5) {
i -> (i * i).toString() }
// 原生类型数组
val x = intArrayOf(1, 2, 3)
println("x[0] + x[1] = ${
x[0] + x[1]}")
// 大小为5、值为 [0, 0, 0, 0, 0] 的整型数组
val array3: IntArray = IntArray(5)
// 例如：用常量初始化数组中的值
// 大小为5、值为 [42, 42, 42, 42, 42] 的整型数组
val array4 = IntArray(5) {
42 }
// 例如：使用 lambda 表达式初始化数组中的值
// 大小为5、值为 [0, 1, 2, 3, 4] 的整型数组 （值初始化为其索引值）
val array5 = IntArray(5) {
it * 1 }
println(array5[4])
/***遍历数组的5种方式***/
// 数组遍历
for (item in array) {
println(item)
}
// 带索引遍历数组
for (i in array.indices) {
println("$i -> ${
array[i]}")
}
// 带索引遍历数组2
for ((index, item) in array.withIndex()) {
println("$index -> $item")
}
//forEach 遍历数组
array.forEach {
println(it) }
//forEach 增强版
array.forEachIndexed {
index, item ->
println("$index -> $item")
}
}
四、走进 Kotlin 的集合
Kotlin 标准库提供了一整套用于管理集合的工具，集合是可变数量（可能为零）的一组条目，各种集合对于解决问题都具有重要意义，并且经常用到。
- List 是一个有序集合，可通过索引访问元素。元素可以在 list 中出现多次。List 列表的顺序很重要并且元素可以重复。
- Set 是唯一元素的集合。一般来说 set 中元素的顺序并不重要。
- Map 是一组键值对。键是唯一的，每个键都刚好映射到一个值，值可以重复。
4.1、集合的可变性与不可变性
在 Kotlin 中存在两种意义上的集合，一种是可以修改的一种是不可修改的。
4.1.1、不可变集合
val stringList = listOf("one", "two", "one")
println(stringList)
val stringSet = setOf("one", "two", "three")
println(stringSet)
4.1.2、可变集合
val numbers = mutableListOf(1, 2, 3, 4)
numbers.add(5)
numbers.removeAt(1)
numbers[0] = 0
println(numbers)
不难发现，每个不可变集合都有对应的可变集合，也就是以 mutable 为前缀的集合。
4.2、集合排序
在 Kotlin 中提供了强大对的集合排序的 API，让我们一起来学习一下：
val numbers = mutableListOf(1, 2, 3, 4)
//随机排列元素
numbers.shuffle()
println(numbers)
numbers.sort()//排序，从小打到
numbers.sortDescending()//从大到小
println(numbers)
//定义一个Person类，有name 和 age 两属性
data class Language(var name: String, var score: Int)
val languageList: MutableList<Language> = mutableListOf()
languageList.add(Language("Java", 80))
languageList.add(Language("Kotlin", 90))
languageList.add(Language("Dart", 99))
languageList.add(Language("C", 80))
//使用sortBy进行排序，适合单条件排序
languageList.sortBy {
it.score }
println(languageList)
//使用sortWith进行排序，适合多条件排序
languageList.sortWith(compareBy(
//it变量是lambda中的隐式参数
{
it.score }, {
it.name })
)
println(languageList)
4.3、集合中的 Set 与 Map
/**set**/
val hello = mutableSetOf("H", "e", "l", "l", "o")//自动过滤重复元素
hello.remove("o")
//集合的加减操作
hello += setOf("w", "o", "r", "l", "d")
println(hello)
/**Map<K, V> 不是 Collection 接口的继承者；但是它也是 Kotlin 的一种集合类型**/
val numbersMap = mapOf("key1" to 1, "key2" to 2, "key3" to 3, "key4" to 1)
println("All keys: ${
numbersMap.keys}")
println("All values: ${
numbersMap.values}")
if ("key2" in numbersMap) println("Value by key \"key2\": ${numbersMap["key2"]}")
if (1 in numbersMap.values) println("1 is in the map")
if (numbersMap.containsValue(1)) println(" 1 is in the map")
五、集合问题
问题1、两个具有相同键值对，但顺序不同的 Map 相等吗？为什么？
问题2、两个具有相同元素，但顺序不同的 list 相等吗？为什么？
/**
* Q1、两个具有相同键值对，但顺序不同的Map相等吗？为什么？
*
*/
val numberMap = mapOf("key1" to 1, "key2" to 2, "key3" to 3, "key4" to 4, "key5" to 5)
val anotherMap = mapOf("key2" to 2, "key1" to 1, "key3" to 3, "key4" to 4, "key5" to 5)
println("anotherMap == numberMap:${
anotherMap == numberMap}")
/**
* Q2、两个具有相同元素，但顺序不同的list相等吗？为什么？
*
*/
val stringList1 = listOf<String>("one", "two", "three")
val stringList2 = listOf<String>("three", "two", "one")
println("stringList1 == stringList2:${
stringList1 == stringList2}")
运行结果如下所示：
可以看到无论键值对的顺序如何，包含相同键值对的两个 Map 是相等的，但是两个具有相同元素，但顺序不同的 list 是不相等的。具体原因的话我们可以去查看源码:
Map 中的比较源码
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof Map))
return false;
Map<?,?> m = (Map<?,?>) o;
if (m.size() != size())
return false;
// 比较源码
try {
Iterator<Entry<K,V>> i = entrySet().iterator();
while (i.hasNext()) {
Entry<K,V> e = i.next();
K key = e.getKey();
V value = e.getValue();
if (value == null) {
// 关键代码
if (!(m.get(key)==null && m.containsKey(key)))
return false;
} else {
if (!value.equals(m.get(key)))
return false;
}
}
} catch (ClassCastException unused) {
return false;
} catch (NullPointerException unused) {
return false;
}
return true;
}
可以看到 Map 的 equals() 方法会去拿出一个 Map 中的一个 key 值，然后查看另外一个 Map 中是否有同样的 key 值，然后再去比较这个两个 key 值所对应的值是否相等就可以了，所以跟顺序是无关的。
List 中的比较源码
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof List))
return false;
ListIterator<E> e1 = listIterator();
ListIterator<?> e2 = ((List<?>) o).listIterator();
while (e1.hasNext() && e2.hasNext()) {
E o1 = e1.next();
Object o2 = e2.next();
// 关键代码
if (!(o1==null ? o2==null : o1.equals(o2)))
return false;
}
return !(e1.hasNext() || e2.hasNext());
}
可以看到 List 的 equals() 方法会去比较每一个索引上对应的值是否相等，所以顺序不同的 list 是不相等的。
六、完整代码
import kotlin.math.abs
fun main() {
println("---main---")
//baseType()
arrayType()
//collectionType()
//collectionSort()
}
fun baseType() {
val num1 = -1.67 // double
val num2 = 2 // Int
val num3 = 2f // Float
val int1 = 3 // Int
println("num1:$num1 num2:$num2 num3:$num3 int1:$int1")
println(abs(num1))
println(num1.toInt()) // 转换成Int
printType(num1)
printType(num2)
printType(num3)
printType(int1)
}
fun printType(param: Any) {
println("$param is ${
param::class.simpleName} type")
}
/**
* 数组
*/
fun arrayType() {
// arrayOf
val array: Array<Int> = arrayOf(1, 2, 3)
// ArrayOfNulls
val array1 = arrayOfNulls<Int>(3)
array1[0] = 4
array1[1] = 5
array1[2] = 6
// 通过Array的构造函数
val array2 = Array(5) {
i -> (i * i).toString() }
// 原生类型数组
val x = intArrayOf(1, 2, 3)
println("x[0] + x[1] = ${
x[0] + x[1]}")
// 大小为5、值为 [0, 0, 0, 0, 0] 的整型数组
val array3: IntArray = IntArray(5)
// 例如：用常量初始化数组中的值
// 大小为5、值为 [42, 42, 42, 42, 42] 的整型数组
val array4 = IntArray(5) {
42 }
// 例如：使用 lambda 表达式初始化数组中的值
// 大小为5、值为 [0, 1, 2, 3, 4] 的整型数组 （值初始化为其索引值）
val array5 = IntArray(5) {
it * 1 }
println(array5[4])
/***遍历数组的5种方式***/
// 数组遍历
for (item in array) {
println(item)
}
// 带索引遍历数组
for (i in array.indices) {
println("$i -> ${
array[i]}")
}
// 带索引遍历数组2
for ((index, item) in array.withIndex()) {
println("$index -> $item")
}
//forEach 遍历数组
array.forEach {
println(it) }
//forEach 增强版
array.forEachIndexed {
index, item ->
println("$index -> $item")
}
}
/**
* 集合
*/
fun collectionType() {
//不可变集合
val stringList = listOf<String>("one", "two", "one")
println(stringList)
val stringSet = setOf<String>("one", "two", "one")
println(stringSet)
// 可变集合
val numbers = mutableListOf<Int>(1, 2, 3, 4)
numbers.add(5)
numbers.removeAt(1)
numbers[0] = 0
println(numbers)
// 自动过滤重复元素
val hello = mutableSetOf("H", "e", "l", "l", "o")
hello.remove("o")
println(hello)
// 集合的加减操作
hello += setOf("w", "o", "r", "l", "d")
println(hello)
/** Map<k, v> 不是 Collection 接口的继承者：但是它也是 Kotlin 的一种集合类型 **/
val numberMap = mapOf("key1" to 1, "key2" to 2, "key3" to 3, "key4" to 4, "key5" to 5)
println("All keys:${
numberMap.keys}")
println("All valus:${
numberMap.values}")
// 判断 key 是否在map里面
if ("key2" in numberMap) println("Value by key2: ${numberMap["key2"]}")
// 判断 value 是否在map里面
if (1 in numberMap.values) println("1 is in the map")
if (numberMap.containsValue(1)) println("1 is in the map")
/**
* Q1、两个具有相同键值对，单顺序不同的Map相等吗？为什么？
*
* 无论键值对的顺序如何，包含相同键值对的两个 Map 是相等的
*/
val anotherMap = mapOf("key2" to 2, "key1" to 1, "key3" to 3, "key4" to 4, "key5" to 5)
println("anotherMap == numberMap:${
anotherMap == numberMap}")
/**
* Q2、两个具有相同元素，但单顺序不同的list相等吗？为什么？
*
* 不相等 源码调试
*/
val stringList1 = listOf<String>("one", "two", "three")
val stringList2 = listOf<String>("one", "two", "three")
println("stringList1 == stringList2:${
stringList1 == stringList2}")
stringList.equals(stringList2)
}
/**
* 集合排序
*/
fun collectionSort() {
val number3 = mutableListOf(1, 2, 3, 4)
// 随机排序
number3.shuffle()
println(number3)
// 从小到大
number3.sort()
println(number3)
// 从大到小
number3.sortDescending()
println(number3)
// 条件排序
data class Language(var name: String, var score: Int)
val languageList = mutableListOf<Language>()
languageList.add(Language("Java", 80))
languageList.add(Language("Kotlin", 90))
languageList.add(Language("Dart", 99))
languageList.add(Language("C", 80))
// 使用sortBy进行排序，适合单条件排序 分数从小到大排序
languageList.sortBy {
it.score
}
println(languageList)
// 使用sortWith进行排序，适合多条件排序
languageList.sortWith(compareBy({
it.score }, {
it.name }))
println(languageList)
}