kotlin知识点大全

第一章、背景

https://www.kotlincn.net/
复制代码

第二章、环境搭建

AS中，Java项目增加Kotlin的支持

new – Activity – Empty Activity – 选择kotlin，然后就增加了kotlin的环境，AS会为我们做下面的2件事情：

1、然后在项目的build.gradle中增加 kotlin的插件

classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
复制代码

2、然后在app的build.gradle中增加插件

id 'kotlin-android'
复制代码

Gradle目录

（windows电脑）C:\Users\93768\.gradle\wrapper\dists

第三章、内置类型

3.1、基本类型

定义

**
**

区别

1、Java中有基本类型和包装类型，Kotlin里面只有包装类型。 

2、Java中表示一个长整形，后面增加 l 或者 L，kotlIn中只能有L（大写）。 

3、Java中整形赋值给Long类型是可以的，但是在kotlin中会出现编译错误。

        val e:Int = 10;
        val f:Long = e;//编译错误，Google认为跨类型赋值是不被允许的
        val g:Long = e.toLong() //采用这样的形式是可以的
复制代码

4、和Java不同，kotlin有无符号类型

5、字符串输入形式不同

        val str = "cdx"
        Log.e("test", "你好$str")
复制代码

6、引入了 === 和 ==，=== 比较的是 引用值，== 比较的是值。

       val str1 = "Hello"
        val str2 = String("Hello".toCharArray())
        // 比较的是引用值
        Log.e("cdx",(str1 === str2).toString()) // false
        // 比较的是值
        Log.e("cdx",(str1 == str2).toString()) // 
复制代码

 7、按照写的方式输出

        val str =
            """
            轻轻的我走了
            正如我轻轻的来
            我轻轻的招手
        """.trimIndent()
        Log.e("cdx", str)
复制代码

3.2、数组

数组的类型

**
**

注意：

Int有整形和整形装箱类型，字符串只有字符串装箱。

例子1:创建一个Int数组的4种方式

        // 创建一个Int类型的数组
        // 第一种方式
        var arr1 = IntArray(5)
        // 第二种方式
        var arr2 = IntArray(5) { it }
        // 第三种方式
        var arr3 = intArrayOf(1, 2, 3, 4, 5)
        // 第四种方式
        var arr4 = Array<Int>(5) { it }
复制代码

例子2：创建一个String类型的数组

        val arr = arrayOf("Hello", "world")
        Log.e(tag, arr.joinToString())
复制代码

3.3、区间

闭区间的使用

        // 闭区间例子
        var arr1: IntRange = 1..10
        Log.e("cdx", arr1.joinToString()) // 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
        var arr2: CharRange = 'a'..'z'
        Log.e("cdx", arr2.joinToString())
        var arr3: LongRange = 1L..100L
        Log.e("cdx", arr3.joinToString())
复制代码

开区间的使用

        // 开区间（左必有开区间）
        var arr4 = 1 until 10 //[1,10)
        Log.e("cdx", arr4.joinToString()) //1, 2, 3, 4, 5, 6, 7, 8, 9
复制代码

倒序区间（Progression：进展、类型）

        // 倒序区间
        var arr5: IntProgression = 10 downTo 1
        Log.e("cdx", arr5.joinToString()) //10, 9, 8, 7, 6, 5, 4, 3, 2, 1
        var arr6 = 'z' downTo 'a'
        Log.e("cdx", arr6.joinToString())
复制代码

区间的步长

        // 区间的步长
        var arr7 = 1..10 step 2
        Log.e("cdx", arr7.joinToString()) // 1, 3, 5, 7, 9
复制代码

1..10 和 1..10 step 2 的类型分别是什么？

**
**

3.4、集合框架

集合框架有几种类型

从可变性上分为：可变集合 + 不可变集合  

从集合的性质上分为：List + Map + Set

区别：

Java的数据结构都是可变的，但是kotlin的数据结构是区分不可变或者可变的。

创建不可变List的2中方式

构造器 +  方法 的创建方法

        // 不可变List使用
        var list = List<String>(5) { "" }
        //list[0] = "1" // 出现编译错误

        var list2 = listOf<String>("Hello", "world")
        //list2[0] = "1"
复制代码

可变List的3种创建方式

        // 可变List
        // 第一种创建方式
        val list1 = MutableList<Int>(5) { it }
        // 第二种创建方式
        var list2 = mutableListOf<Int>(1)
        // 第三种创建的方式
        var list3 = ArrayList<Int>()

        list1[3] = 4
        Log.e(tag, list1.joinToString("*"))
        // 超出边界将阻碍下面的语句的执行
        list1[8] = 8
        list1.set(2, 5)
        Log.e(tag, list1.joinToString("*"))
复制代码

ArrayList使用

	// 这个默认是:MutableList
        val list3 = ArrayList<String>()
        list3.add("a")
        list3.add("b")
        list3 += "c" //注意 += 就是add的操作
        list3.remove("b") //
        list3 -= "a" // -= 就是remove操作
        Log.e("cdx", list3.joinToString()) //c
复制代码

不可变Map创建的2种方式

to + Pair 方式

        // 不可变Map
        val map: Map<String, Any> = mapOf("name" to "xiaohong", "age" to 20)
        val map = mapOf<String, String>(Pair("name", "张三"), Pair("age", "10"))
复制代码

可变Map

        // 可变Map
        val map2: MutableMap<String, Any> = mutableMapOf("name" to "xiaohong", "age" to 20)
        map2["name"] = 3
        map2.put("weight", 160)
        //遍历Map的key-value对，entris元素返回key-value对组成的Set
        for (en in map2.entries) {
            Log.e("cdx", "${en.key}->${en.value}")
        }
复制代码

Pair（对）

	val pair = "Hello" to "kotlin"
        val pair2 = Pair("Hello", "kotlin")
        val first = pair2.first
        val second = pair2.second
        // 解构赋值
        val (x, y) = pair
        Log.e(
            "cdx",
            "first:$first,second:$second,x:$x,y:$y"
        ) //  first:Hello,second:kotlin,x:Hello,y:kotlin
复制代码

Triple（三倍的）

和Pair使用类似

3.5、函数

定义

类似于java中的方法。

一个函数没有返回值，返回类型是什么？

Unit类似于Java的void，可以省略。

    private fun test4(): Unit {

    }
复制代码

函数VS方法

test方法外面有一个Test（类），那么test就是一个方法。

class Test {
    fun test(): String {
        return ""
    }
}
复制代码

函数的引用

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

利用**：：**来实现获取函数的引用。

方法函数的引用 和 引用的类型是什么

首先定义方法

    private fun test(str: String): Unit {

    }
复制代码

然后获取方法的引用

 	// 定义fun1来接受方法的引用, (String) -> Unit表示函数的类型。
        // 其中(String) -> Unit类型可以省略
        val fun1: (String) -> Unit = ::test
复制代码

类中方法的引用

package com.example.kotlindemo

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // 接受一个方法的引用,这两个是等价的,表示括号里和哪些有关系
        // 第一个表示有Receiver，第二个形式表示和Test有关系
        val fun2: Test.() -> String = Test::test
        val fun3: (Test) -> String = Test::test

        // 对象取函数的引用,类型不一样了
        val test = Test()
        val fun4: () -> String = test::test

	// 函数里面有函数，并且调用
        test1(::test)
        test1(fun1)
    }

    /**
     * 这个test1函数的类型是一个函数，函数的参数是String类型，返回时是Unit类型，也就是void类型
     */
    private fun test1(p: (String) -> Unit) {
        p("Hello")
    }

    private fun test(str: String): Unit {

    }

}

class Test {
    // 这个就是方法
    fun test(): String {
        return ""
    }
}
复制代码

对象方法的引用

        // 对象取函数的引用,类型不一样了
        val test = Test()
        val fun1: () -> Unit = test::test
复制代码

变长参数

vararg 用来修饰参数，就变成了变长参数，类似于数组。

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        Log.e("cdx",test("1", "2"))
    }

    // 边长参数：类似于数组
    // 使用关键字 vararg
    fun test(vararg params: String): String {
        return params.size.toString();
    }

}
复制代码

多返回值接受的两种方式（通常方式、解构赋值）

class MainActivity2 : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main2)

        // 第一种接受方式
        val test = test()
        // 第二种接受方式：结构赋值
        val (a,b,c) = test()
        Log.e("cdx",test.toString())
    }

    fun test(): Triple<Int, Long, Double> {
        return Triple(1, 2L, 3.0)
    }
}
复制代码