欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

给 Android 开发者的 Kotlin 教程(二)

程序员文章站 2022-07-03 08:22:37
一、Kotlin 概述在 给 Android 开发者的 Kotlin 教程(一)中我们Google 在2019年的 Google I/O 大会上宣布 Kotlin 被选为 Android 开发首选语言。1.1、Kotlin 特点简洁易用: Kotlin中提供了大量的扩展,使得我们的代码更加简洁,开发出来的框架更加易用;安全: 避免空指针异常等整个类的错误;互操作性: 充分利用 JVM、Android 和浏览器的现有库;工具友好: 可用任何 Java IDE 或者使用命令行构建。1.2、学...

一、Kotlin 必备基础

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

代码运行结果如下所示:
给 Android 开发者的 Kotlin 教程(二)

三、走进 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}")

运行结果如下所示:
给 Android 开发者的 Kotlin 教程(二)
可以看到无论键值对的顺序如何,包含相同键值对的两个 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)
}

本文地址:https://blog.csdn.net/weixin_38478780/article/details/108658324