Kotlin学习笔记

最新推荐文章于 2024-05-22 10:17:53 发布

「已注销」

最新推荐文章于 2024-05-22 10:17:53 发布

阅读量517

点赞数 2

分类专栏： Android开发文章标签： android kotlin

本文链接：https://blog.csdn.net/fakerXuan/article/details/115764764

版权

这篇博客详细介绍了Kotlin语言，包括其概述、特点、设计理念、构建流程及基础语法，如数据类型、数组、集合、方法与Lambda表达式、类与接口、泛型、注解和扩展等。Kotlin在Android开发中的重要性以及它如何简化代码和提高开发效率也得到了强调。

摘要由CSDN通过智能技术生成

文章目录

Kotlin概述

一种在Java虚拟机上运行的静态类型编程语言
可以和Java代码相互操作
容易在Android项目中代替Java或者同Java一起使用
在2019年的Google I/O大会上Kotlin被选为Android开发者首选语言

Kotlin特点

简洁易用
安全
互操作性
工具友好

Kotlin设计理念

Readability
Reuse
Interoperablity
Safety
Tooling

Kotlin构建流程

在这里插入图片描述

Kotlin必备基础

Kotlin基本数据类型

在这里插入图片描述

Kotlin的数组

在这里插入图片描述

生成数组的方式

/**
 * 数组
 */
fun arrayType() {
   
    //arrayOf
    val array = arrayOf(1, 2, 3)

    //arrayOfNulls
    val array1 = arrayOfNulls<Int>(3)
    array1[0] = 4
    array1[1] = 5
    array1[2] = 6

    //Array(5)的构造函数
    val array2 = Array(5) {
    i -> (i * i).toString() }

//    intArrayOf(),doubleArrayOf()
    val x: IntArray = intArrayOf(1, 2, 3)
    println("x[0] + x[1] = ${x[0] + x[1]}")

    // 大小为 5、值为 [0, 0, 0, 0, 0] 的整型数组
    val array3 = 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种方式

    /****遍历数组的常用5中方式****/
    //数组遍历
    for (item in array) {
   
        println(item)
    }

    //带索引遍历数组
    for (i in array.indices) {
   
        println("$i -> ${array[i]}")
    }

    // 遍历元素(带索引)
    for ((index, item) in array.withIndex()) {
   
        println("$index -> $item ")
    }
    //forEach遍历数组
    array.forEach {
    println(it) }

    // forEach增强版
    array.forEachIndexed {
    index, item ->
        println("$index -> $item ")
    }
}

Kotlin的集合

在这里插入图片描述

集合的可变性与不可变性
在Kotlin存在两种意义上的集合，一种是可以修改的一种是不可修改的

每个不可变集合都有对应的可变集合，也就是以mutable为前缀的集合。
测试代码

/**
 * 集合
 */
fun collectionType() {
   
    //不可变集合
    val stringList = listOf("one", "two", "one")
    println(stringList)

    val stringSet = setOf("one", "two", "one")
    println(stringSet)

    //可变集合

    val numbers = mutableListOf(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 values:${numberMap.values}")

    if ("key2" in numberMap) println("Value by key key2:${numberMap["key2"]}")
    if (1 in numberMap.values) println("1 is in the map")
    if (numberMap.containsValue(1)) println("1 is in the map")

    /**
     * Q1：两个具有相同键值对，但顺序不同的map相等吗？为什么？
     * 无论键值对的顺序如何，包含相同键值对的两个 Map 是相等的
     * 具体原因可参看equals源码
     */
    val anotherMap = mapOf("key2" to 2, "key1" to 1, "key3" to 3, "key4" to 4, "key5" to 5)
    println("anotherMap == numberMap:${anotherMap == numberMap}")
    anotherMap.equals(numberMap)
    /**
     * Q2：两个具有相同元素，但顺序不同的list相等吗？为什么？
     */
}

集合排序

/**
 * 集合排序
 */
fun collectionSort() {
   
    val number3 = mutableListOf(1, 2, 3, 4)
    //随机排序
    number3.shuffle()
    println(number3)

    number3.sort()//从小到大
    number3.sortDescending()//从大到小
    println(number3)

    //条件排序

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

Kotlin方法与Lambda表达式

方法声明
测试代码

/**---------方法声明---------**/
fun functionLearn(days: Int): Boolean {
   
    Person().test1()
    Person.test2()
    println("NumUtil.double(2):${
     NumUtil.double(2)}")
    println("double(3):${
     double(3)}")
    return days > 100
}


class Person {
   
    /**
     * 成员方法
     */
    fun test1() {
   
        println("成员方法")
    }

    /**
     * 类方法：Kotlin中并没有static关键字，不过我们可以借助companion object 来实现类方法的目的
     */
    companion object {
   
        fun test2() {
   
            println("companion object 实现的类方法")