kotlin 基本api

关键字

• fun：定义函数。
• val：定义只读变量，相当于 Java 中的 final。
• var：定义可变变量。
• if、else：条件语句。
• when：类似于 Java 中的 switch，但更强大。
• for、while：循环语句。
• return：返回语句。
• class、interface、object：定义类、接口、对象。
• package：定义包。
• import：导入其他包中的类或函数。
• this、super：引用当前实例或父类实例。
• is、as：类型检查和类型转换。
• try、catch、finally：异常处理。

基本数据类型和数组

在 Kotlin 中，基本数据类型和数组包括：

基本数据类型：

1. Byte：8 位有符号整数。
2. Short：16 位有符号整数。
3. Int：32 位有符号整数。
4. Long：64 位有符号整数。
5. Float：32 位浮点数。
6. Double：64 位浮点数。
7. Char：16 位 Unicode 字符。
8. Boolean：布尔值，true 或 false。

数组：

Kotlin 中的数组使用 Array 类表示，可以定义不同类型的数组。常见的数组定义方式如下：

// 定义整型数组
val intArray: Array<Int> = arrayOf(1, 2, 3, 4, 5)

// 定义字符串数组
val stringArray: Array<String> = arrayOf("apple", "banana", "orange")

// 定义混合类型数组
val mixedArray: Array<Any> = arrayOf(1, "two", 3.0, true)

Kotlin 还提供了原生类型数组，例如 IntArray、DoubleArray、BooleanArray 等，这些数组在性能上比 Array 更高效。例如：

// 定义整型数组
val intArray: IntArray = intArrayOf(1, 2, 3, 4, 5)

// 定义布尔数组
val booleanArray: BooleanArray = booleanArrayOf(true, false, true)

在 Kotlin 中，你可以使用不同的循环结构来遍历数组，包括 for、forEach、while 和 do-while 循环。

使用 for 循环：

val array = arrayOf(1, 2, 3, 4, 5)

for (element in array) {
    println(element)
}

使用 forEach 循环：

val array = arrayOf(1, 2, 3, 4, 5)

array.forEach { element ->
    println(element)
}

使用 while 循环：

val array = arrayOf(1, 2, 3, 4, 5)
var index = 0

while (index < array.size) {
    println(array[index])
    index++
}

使用 do-while 循环：

val array = arrayOf(1, 2, 3, 4, 5)
var index = 0

do {
    println(array[index])
    index++
} while (index < array.size)

这些循环结构可以根据需求选择，通常来说，for 循环用于遍历数组，forEach 用于执行每个元素的操作，而 while 和 do-while 循环则可以根据特定条件进行循环。

集合容器

在 Kotlin 中，有许多不同类型的集合容器可用。这些容器包括：

1. List（列表）：有序集合，允许重复元素。

   • listOf()：不可变列表。
   • mutableListOf()：可变列表。
   • arrayListOf()：可变列表，基于数组实现。

2. Set（集合）：无序集合，不允许重复元素。

   • setOf()：不可变集合。
   • mutableSetOf()：可变集合。
   • hashSetOf()：可变集合，基于哈希表实现。

3. Map（映射）：键值对的集合。

   • mapOf()：不可变映射。
   • mutableMapOf()：可变映射。
   • hashMapOf()：可变映射，基于哈希表实现。

4. Array（数组）：固定大小的有序集合。

   • arrayOf()：不可变数组。
   • intArrayOf()、floatArrayOf() 等：基本类型数组。
   • Array(size) { }：可变大小的数组。

这些集合容器提供了丰富的功能和灵活性，可以根据不同的需求选择合适的容器类型。例如，如果需要一个有序集合且允许重复元素，可以选择 List；如果需要一个键值对的映射关系，可以选择 Map。

以下是一些示例，演示了如何在 Kotlin 中使用不同类型的集合容器：

List（列表）：

// 创建一个不可变列表
val immutableList = listOf("apple", "banana", "orange")

// 创建一个可变列表
val mutableList = mutableListOf("apple", "banana", "orange")
mutableList.add("grape")

// 遍历列表
for (item in immutableList) {
    println(item)
}

Set（集合）：

// 创建一个不可变集合
val immutableSet = setOf("apple", "banana", "orange")

// 创建一个可变集合
val mutableSet = mutableSetOf("apple", "banana", "orange")
mutableSet.add("grape")

// 遍历集合
for (item in immutableSet) {
    println(item)
}

Map（映射）：

// 创建一个不可变映射
val immutableMap = mapOf(1 to "apple", 2 to "banana", 3 to "orange")

// 创建一个可变映射
val mutableMap = mutableMapOf(1 to "apple", 2 to "banana", 3 to "orange")
mutableMap[4] = "grape"

// 遍历映射
for ((key, value) in immutableMap) {
    println("Key: $key, Value: $value")
}

Array（数组）：

// 创建一个不可变数组
val immutableArray = arrayOf("apple", "banana", "orange")

// 创建一个可变数组
val mutableArray = mutableListOf("apple", "banana", "orange")
mutableArray.add("grape")

// 遍历数组
for (item in immutableArray) {
    println(item)
}

这些示例展示了如何创建、添加元素和遍历不同类型的集合容器。根据具体需求，你可以选择合适的集合类型，并使用相应的操作方法来处理数据。

异步协程

在 Kotlin 中，可以使用协程（Coroutines）来实现异步编程。协程是一种轻量级的并发机制，可以在代码中以顺序的方式表达异步操作，而不需要回调或者显式的线程管理。以下是使用协程实现异步操作的示例：

import kotlinx.coroutines.*

fun main() {
    // 启动一个协程
    GlobalScope.launch {
        println("Start coroutine")

        // 模拟耗时操作
        delay(1000)

        println("Async operation completed")
    }

    println("Main thread continues")

    // 防止 JVM 提前退出
    Thread.sleep(2000)
}

在上面的示例中，使用 GlobalScope.launch 函数启动了一个协程。在协程中，通过 delay 函数模拟了一个异步操作，等待 1 秒钟后输出异步操作完成的消息。在主线程中，输出了 "Main thread continues" 消息。

总的来说，使用协程可以使异步编程变得更简单、更直观，而不需要显式地管理线程或者回调。通过使用 launch 函数创建协程，结合挂起函数（如 delay）等工具，可以轻松地实现异步操作。

协程通信

在 Kotlin 协程中进行通信通常使用挂起函数和协程之间的协作。以下是一些常见的协程通信方式：

使用 Channel：

Channel 是一种协程间通信的方式，它提供了生产者-消费者模型。生产者可以向通道发送数据，消费者可以从通道接收数据。

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*

fun main() = runBlocking {
    val channel = Channel<Int>()

    // 启动生产者协程
    launch {
        for (i in 1..5) {
            delay(200)
            channel.send(i)
        }
        channel.close()
    }

    // 启动消费者协程
    launch {
        for (element in channel) {
            println("Received: $element")
        }
    }

    // 等待协程执行完成
    delay(2000)
}

使用共享变量：

通过共享变量来进行协程间通信也是一种常见的方式，但需要注意线程安全性。

import kotlinx.coroutines.*
import kotlin.concurrent.thread

fun main() = runBlocking {
    var result: String? = null

    // 启动异步任务
    val job = GlobalScope.launch {
        delay(1000)
        result = "Hello from Coroutines"
    }

    // 启动另一个线程，等待异步任务完成
    thread {
        job.join()
        println(result)
    }
}

在这个例子中，我们启动了一个协程来执行异步任务，并且在另一个线程中等待协程的完成，并且访问了共享变量 result。

总的来说，Kotlin 协程提供了多种方式来实现协程间的通信，包括 Channel、共享变量和其他同步机制。选择合适的通信方式取决于具体的需求和场景。

定义方法和函数

在 Kotlin 中，定义方法和函数有一些不同之处，但本质上都是为了封装代码块以便重用。以下是方法和函数的定义方式：

函数（Functions）：

在 Kotlin 中，函数是顶层的（即不属于任何类或对象），也可以定义在类中。

// 定义顶层函数
fun greet(name: String) {
    println("Hello, $name!")
}

// 定义在类中的函数
class MyClass {
    fun displayMessage() {
        println("This is a message from MyClass.")
    }
}

方法（Methods）：

方法是与类相关联的函数，在类中定义。方法可以访问类的属性和其他方法。

class Calculator {
    // 定义方法
    fun add(a: Int, b: Int): Int {
        return a + b
    }

    // 也可以写成单表达式函数
    fun subtract(a: Int, b: Int) = a - b
}

调用函数和方法：

fun main() {
    // 调用函数
    greet("Alice")

    // 创建类的实例
    val calculator = Calculator()

    // 调用方法
    val sum = calculator.add(3, 5)
    println("Sum: $sum")

    val difference = calculator.subtract(10, 3)
    println("Difference: $difference")
}

在 Kotlin 中，函数和方法的定义方式类似，但函数可以是顶层的，而方法必须定义在类中。调用函数和方法时，使用相应的名称加上参数列表即可。

定义类

在 Kotlin 中，你可以使用关键字 class 来定义一个类。下面是一个简单的类的定义示例：

class MyClass {
    // 属性
    var name: String = ""
    var age: Int = 0

    // 方法
    fun introduce() {
        println("Hello, my name is $name and I am $age years old.")
    }
}

在这个示例中，MyClass 是类的名称，类中包含了两个属性 name 和 age，以及一个方法 introduce()。

创建类的实例：

fun main() {
    // 创建类的实例
    val person = MyClass()

    // 设置属性值
    person.name = "Alice"
    person.age = 30

    // 调用方法
    person.introduce()
}

在 main() 函数中，我们创建了 MyClass 的一个实例 person，并设置了其属性值。然后调用了 introduce() 方法，输出了相应的信息。

这就是在 Kotlin 中定义和使用类的基本方式。你可以在类中定义属性和方法，并且可以通过创建类的实例来访问和操作它们。

项目结构

在 Kotlin 项目中，通常会使用标准的项目结构来组织代码和资源文件。以下是一个典型的 Kotlin 项目结构示例：

project/
│
├── src/
│   ├── main/
│   │   ├── kotlin/
│   │   │   └── com/
│   │   │       └── example/
│   │   │           └── MyApplication.kt
│   │   └── resources/
│   │       └── config.properties
│   │
│   └── test/
│       └── kotlin/
│           └── com/
│               └── example/
│                   └── MyApplicationTest.kt
│
├── build.gradle.kts
└── settings.gradle.kts

这是一个典型的 Gradle 项目结构，但对于 Maven 项目，结构也非常相似。让我们来解释一下各个目录的作用：

• src/main/kotlin：主要源代码目录，包含项目的 Kotlin 源代码文件。通常你的应用程序的主要功能代码都放在这里。
• src/main/resources：主要资源目录，包含项目的资源文件，如配置文件、图片等。这些文件将被打包到项目的输出文件中。
• src/test/kotlin：测试源代码目录，包含项目的测试代码文件。通常使用测试框架（如 JUnit）编写测试用例，并将其放在这个目录下。
• build.gradle.kts：Gradle 构建脚本，用于定义项目的构建配置和依赖关系。
• settings.gradle.kts：Gradle 设置脚本，用于定义项目的模块和子项目。

这样的项目结构有助于组织和管理代码，使得代码结构清晰，并且方便使用构建工具进行构建和管理。

编译、运行、部署

在 Kotlin 项目中，编译、运行和部署通常使用构建工具（如 Gradle 或 Maven）来完成。以下是使用 Gradle 的示例：

编译项目：

1. 在项目根目录下创建一个名为 build.gradle.kts 的 Gradle 构建脚本文件。

2. 在构建脚本中指定 Kotlin 插件和项目依赖。

plugins {
    kotlin("jvm") version "1.5.10"
}

repositories {
    mavenCentral()
}

dependencies {
    implementation(kotlin("stdlib"))
    // 添加其他依赖
}

3. 在命令行中运行 ./gradlew build（Linux/MacOS）或 gradlew.bat build（Windows）命令来编译项目。编译后的输出文件位于 build/libs/ 目录下。

运行项目：

1. 在命令行中运行 ./gradlew run（Linux/MacOS）或 gradlew.bat run（Windows）命令来运行项目。前提是你的项目中已经配置了运行任务。

部署项目：

1. 编译项目后，你可以将生成的 JAR 文件（或其他格式的输出文件）部署到你想要的位置。这可能是服务器、云平台等。

2. 将项目的依赖项一同部署，确保部署环境中具有所需的运行时环境和依赖项。

这是一个基本的流程，具体的操作可能会因项目类型、构建工具和部署环境的不同而有所差异。