杂项

class MyClass {
    companion object Factory {
        fun create(): MyClass = MyClass()
    }
}

fun main() {
    val instance = MyClass.create()  // 通过伴生对象访问创建类实例的方法
}

class MyClass {
    companion object {
        val allBooks = mutableListOf<String>()

        // 伴生对象的初始化代码块
        init {
            // 初始化逻辑，例如添加默认数据
            allBooks.add("Kotlin Programming")
            allBooks.add("Advanced Kotlin")
        }

        fun listBooks(): List<String> = allBooks
    }
}

fun main() {
    // 访问伴生对象的成员，触发伴生对象的初始化
    println(MyClass.listBooks())  // 输出初始化时添加的书籍列表
}

val str: String? = "Hello"
str?.let {
    // 在这个作用域内，it 指向 str
    println(it.length) // 使用 it 访问 str 的属性
}

val builder = StringBuilder()
with(builder) {
    append("Hello, ")
    append("world!")
    toString() // 这个表达式的结果（即最终的字符串）被 `with` 返回
}

val result = "Hello".run {
    length // 返回字符串长度
}

val list = mutableListOf(1, 2, 3).apply {
    add(4) // 添加元素到列表
}
// list 变量持有已经被配置的 MutableList

val numbers = mutableListOf("one", "two", "three").also {
    println("The list elements before adding new one: $it")
}.apply {
    add("four")
}

fun sendTransactionWithGettingReceipt(transaction: Transaction, password: String): Receipt {
    val tBlockHash = this.sendTBlock(transaction, password)
    val tryGetReceipt: suspend () -> Receipt = {
        try {
            this.getReceipt(tBlockHash)
        } catch (e: Error) {
            delay(1000)
            Receipt()
        }
    }

    var receipt = Receipt()
    runBlocking {
        var times = 0
        while (times < 10) {
            receipt = tryGetReceipt()
            if (receipt.tblockHash.isBlank()) times++ else break
        }
    }
    if (receipt.tblockHash.isBlank()) receipt.tblockHash = tBlockHash
    return receipt
}

import kotlinx.coroutines.async
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.awaitAll

fun main() = runBlocking {
    val deferredResult1 = async { // 在后台启动一个新的协程并继续
        delay(1000L) // 模拟一个长时间的运算
        "Result1" // 返回结果
    }
    val deferredResult2 = async {
        delay(2000L) // 另一个长时间的运算
        "Result2" // 返回结果
    }
    // 等待所有的协程完成，并获取结果
    val results = awaitAll(deferredResult1, deferredResult2)
    println("Got results: $results")
}

import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.withContext
import kotlinx.coroutines.Dispatchers

fun main() = runBlocking {
    val result = withContext(Dispatchers.IO) { // 切换到IO线程执行
        // 执行一些IO操作
        "Result from IO"
    }
    println(result)
}

import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking

fun main() = runBlocking {
    val job1 = launch {
        delay(1000L)
        println("Task 1 completed")
    }
    val job2 = launch {
        delay(2000L)
        println("Task 2 completed")
    }
    // 等待任务完成
    job1.join()
    job2.join()
    println("All tasks completed.")
}

import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking

fun main() = runBlocking {
    coroutineScope { // 创建一个协程作用域
        launch {
            delay(1000L)
            println("Task 1 completed")
        }
        launch {
            delay(2000L)
            println("Task 2 completed")
        }
    }
    // 在所有任务完成后执行
    println("All tasks completed in scope.")
}

import kotlinx.coroutines.*
import kotlinx.coroutines.selects.select

suspend fun task1(): String {
    delay(1000L) // 模拟耗时任务
    return "Result1"
}

suspend fun task2(): String {
    delay(200L) // 模拟较短耗时任务
    return "Result2"
}

fun main() = runBlocking {
    val result = select<String> { // 选择第一个完成的协程
        async { task1() }.onAwait { it }
        async { task2() }.onAwait { it }
    }
    println("First result is '$result'")
}