轩辕李的博客
轩辕李
2025-02-08
目录

Kotlin历代版本新特性

# 前言

Kotlin 由 JetBrains 于2011年首次公开，2016年发布1.0正式版本。作为一门现代化的 JVM 语言，Kotlin 以其简洁、安全和强大的表现力迅速赢得开发者青睐。

2017年，Google 宣布 Kotlin 成为 Android 官方开发语言，标志着 Kotlin 进入快速发展期。如今，Kotlin 不仅在 Android 开发中占据主导地位，在服务器端开发、跨平台开发（Kotlin Multiplatform）等领域也展现出强大的生命力。

本文系统梳理了 Kotlin 从1.0到最新版本的核心特性和发展历程。对于每个版本，我们会重点介绍那些影响深远的特性和重要的语法改进。

阅读建议：

  • 标记为 粗体 的特性通常是该版本最重要的改进
  • Kotlin 1.1（协程）、1.3（多平台）、2.0（K2编译器）是重要里程碑
  • 代码示例可以帮助你快速理解新特性的用法

# Kotlin版本发布流程

Kotlin 由 JetBrains 主导开发，采用社区驱动的开源模式，通过 KEEP（Kotlin Evolution and Enhancement Process）提案系统管理语言演进。

# 关键特点

  • 稳定版本保持向后兼容性
  • 采用语义化版本控制（主版本.次版本.修订版）
  • 实验性特性需要显式选择加入（Opt-in）
  • 每个特性版本间隔数月至一年

# 全流程步骤

# 1. 提案阶段（KEEP）

  • 社区成员或 JetBrains 团队提交 KEEP 提案
  • KEEP 描述问题、解决方案、示例和影响
  • 在 GitHub 上公开讨论和审查

# 2. 实验性实现

  • 通过特性标志启用实验性功能
  • 收集社区反馈和使用经验
  • 根据反馈调整设计

# 3. Beta 阶段

  • 特性趋于稳定但仍可能有小幅调整
  • 鼓励在生产环境试用
  • API 基本固定

# 4. 稳定发布

  • 特性正式稳定，保证向后兼容
  • 包含在正式版本中
  • 提供完整文档和迁移指南

# 5. 持续维护

  • 定期发布修订版本修复 bug
  • 性能优化和工具改进
  • 弃用过时特性（提供迁移期）

# 治理模型

  • 主导组织：JetBrains
  • 治理模型：开放治理，社区参与，JetBrains 最终决策
  • 主要贡献者：JetBrains、Google、社区开发者

# 1.0（2016年2月）

2016年2月15日发布，是 Kotlin 的首个正式稳定版本。

# 核心承诺

  • 向后兼容性保证：承诺所有后续版本与1.0保持兼容
  • 生产就绪：可用于实际项目开发
  • 完整的 Java 互操作：与 Java 代码无缝集成

# 核心特性

  • 空安全类型系统：编译时消除 NPE

    var name: String = "Kotlin"  // 不可为 null
var nullableName: String? = null  // 可为 null

val length = nullableName?.length ?: 0  // 安全调用和 Elvis 操作符

  • 扩展函数：为现有类添加新方法

    fun String.removeWhitespace(): String {
    return this.replace("\\s+".toRegex(), "")
}

val text = "Hello World".removeWhitespace()  // "HelloWorld"

  • 数据类：自动生成 equals、hashCode、toString

    data class User(val name: String, val age: Int)

val user1 = User("张三", 25)
val user2 = user1.copy(age = 26)  // 复制并修改

  • Lambda 表达式和高阶函数：函数式编程支持

    val numbers = listOf(1, 2, 3, 4, 5)
val doubled = numbers.map { it * 2 }
val evens = numbers.filter { it % 2 == 0 }

  • 字符串模板：简化字符串拼接

    val name = "Kotlin"
val message = "Hello, $name! Length is ${name.length}"

  • 智能类型转换：自动类型推断

    fun demo(x: Any) {
    if (x is String) {
        println(x.length)  // x 自动转换为 String
    }
}

  • When 表达式：强大的模式匹配

    when (x) {
    1 -> print("一")
    2, 3 -> print("二或三")
    in 4..10 -> print("四到十")
    is String -> print("字符串")
    else -> print("其他")
}

  • 委托属性：属性委托模式

    class Example {
    var p: String by Delegate()
}

val lazyValue: String by lazy {
    println("计算中...")
    "Hello"
}

# 工具支持

  • IntelliJ IDEA 完整支持
  • Eclipse 插件
  • Maven 和 Gradle 构建工具支持

# 1.1（2017年3月）

2017年3月1日发布，引入协程等重要特性。

# 革命性特性

# 1. 协程（Coroutines）- 实验性

轻量级的异步编程支持。

// 异步加载图片
fun asyncOverlay() = async(CommonPool) {
    val original = asyncLoadImage("original")
    val overlay = asyncLoadImage("overlay")
    applyOverlay(original.await(), overlay.await())
}

launch(UI) {
    val image = asyncOverlay().await()
    showImage(image)
}

// 生成序列
val fibonacci = buildSequence {
    var a = 0
    var b = 1
    yield(a)
    while (true) {
        yield(b)
        val next = a + b
        a = b
        b = next
    }
}

# 2. 类型别名（Type Aliases）

为现有类型创建别名。

typealias UserId = String
typealias UserMap = Map<UserId, User>
typealias Predicate<T> = (T) -> Boolean

fun findUser(users: UserMap, condition: Predicate<User>): User? {
    return users.values.find(condition)
}

# 3. 绑定的可调用引用

可以引用特定实例的成员。

val numberRegex = "\\d+".toRegex()
val isNumber = numberRegex::matches
println(isNumber("123"))  // true

val numbers = listOf("abc", "123", "456").filter(numberRegex::matches)

# 语法增强

# Sealed 类和 Data 类增强

// Sealed 类的子类可以在顶层定义
sealed class Expr
data class Const(val number: Double) : Expr()
data class Sum(val e1: Expr, val e2: Expr) : Expr()
object NotANumber : Expr()

// Data 类可以继承其他类
open class Base
data class Derived(val value: Int) : Base()

# Lambda 中的解构

val map = mapOf("a" to 1, "b" to 2)
map.mapValues { (key, value) -> "$key -> $value!" }

// 未使用的变量用下划线
map.forEach { (_, value) -> println("$value!") }

# 数字字面量中的下划线

val oneMillion = 1_000_000
val creditCard = 1234_5678_9012_3456L
val hexBytes = 0xFF_EC_DE_5E
val bytes = 0b11010010_01101001_10010100_10010010

# 标准库增强

  • 字符串到数字转换：toIntOrNull()、toDoubleOrNull()

    val port = System.getenv("PORT")?.toIntOrNull() ?: 80

  • 作用域函数：also()、takeIf()、takeUnless()

    val file = File("test.txt")
    .takeIf { it.exists() }
    ?.takeUnless { it.isDirectory }

fun Block.copy() = Block().also {
    it.content = this.content
}

  • 集合操作：groupingBy()、Map.minus()、minOf()、maxOf()

    val words = listOf("a", "abc", "ab", "def", "abcd")
val frequencies = words.groupingBy { it.first() }.eachCount()

val map = mapOf("key" to 42)
val emptyMap = map - "key"

# 平台支持

  • JavaScript 后端：统一标准库，external 修饰符
  • Java 8 支持：生成 Java 8 字节码，支持 Java 8 标准库

# 1.2（2017年11月）

2017年11月28日发布，引入多平台项目支持（重要），为跨平台开发提供支持。

# 核心特性

# 1. 多平台项目（实验性）

允许在不同平台间共享代码。

// 公共代码
expect fun platformName(): String

// JVM 平台
actual fun platformName(): String = "JVM"

// JS 平台
actual fun platformName(): String = "JavaScript"

// 使用
fun greet() = "Hello from ${platformName()}"

# 2. 数组字面量注解

@RequestMapping(value = ["value1", "value2"], path = ["path1", "path2"])
fun handler() { }

# 3. lateinit 检查

class Example {
    lateinit var name: String
    
    fun initialize() {
        if (::name.isInitialized) {
            println("已初始化")
        }
    }
}

# 4. 内联函数支持默认参数

inline fun <T> Collection<T>.printAll(
    prefix: String = "",
    postfix: String = ""
) {
    forEach { println("$prefix$it$postfix") }
}

# 标准库

  • kotlin.math：数学函数统一到标准库

    import kotlin.math.*

val angle = PI / 4
val result = sin(angle)

  • 集合增强：chunked()、windowed()、fill()

    val items = (1..9).chunked(3)  // [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

val numbers = listOf(1, 2, 3, 4, 5)
val windows = numbers.windowed(3)  // [[1, 2, 3], [2, 3, 4], [3, 4, 5]]

# 1.3（2018年10月）

2018年10月29日发布，完善协程和多平台支持。

# 核心特性

# 1. 协程正式稳定

协程从实验性转为稳定特性。

// 结构化并发
suspend fun fetchData(): Data = coroutineScope {
    val user = async { fetchUser() }
    val orders = async { fetchOrders() }
    Data(user.await(), orders.await())
}

// 协程作用域
class MyActivity : CoroutineScope {
    private val job = Job()
    override val coroutineContext = Dispatchers.Main + job
    
    fun loadData() = launch {
        val data = withContext(Dispatchers.IO) {
            fetchFromNetwork()
        }
        updateUI(data)
    }
    
    fun onDestroy() {
        job.cancel()
    }
}

# 2. 多平台项目改进

完全重新设计的多平台模型。

kotlin {
    jvm()
    js()
    
    sourceSets {
        val commonMain by getting {
            dependencies {
                implementation(kotlin("stdlib-common"))
            }
        }
        val jvmMain by getting {
            dependencies {
                implementation(kotlin("stdlib-jdk8"))
            }
        }
        val jsMain by getting {
            dependencies {
                implementation(kotlin("stdlib-js"))
            }
        }
    }
}

# 3. 契约（Contracts）- 实验性

向编译器提供函数行为信息。

@OptIn(ExperimentalContracts::class)
fun String?.isNotNullOrEmpty(): Boolean {
    contract {
        returns(true) implies (this@isNotNullOrEmpty != null)
    }
    return this != null && this.isNotEmpty()
}

fun process(s: String?) {
    if (s.isNotNullOrEmpty()) {
        println(s.length)  // 智能转换为非空
    }
}

# 语法增强

# when 中的变量捕获

fun Request.getBody() =
    when (val response = executeRequest()) {
        is Success -> response.body
        is HttpError -> throw HttpException(response.status)
    }

# 接口中的伴生对象实现接口

interface Factory<T> {
    fun create(): T
}

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

# 标准库

  • 随机数 API：kotlin.random.Random

    val number = Random.nextInt(100)
val bytes = Random.nextBytes(10)

  • Boolean 伴生对象

    val randomBoolean = Random.nextBoolean()

# 1.4（2020年8月）

2020年8月17日发布，聚焦质量和性能改进。

# 核心特性

# 1. SAM 转换

支持 Kotlin 接口的 SAM 转换。

fun interface IntPredicate {
    fun accept(i: Int): Boolean
}

// Lambda 自动转换
val isEven = IntPredicate { it % 2 == 0 }

fun check(list: List<Int>, predicate: IntPredicate) {
    list.filter { predicate.accept(it) }
}

# 2. 显式 API 模式

要求明确声明可见性和类型。

// build.gradle.kts
kotlin {
    explicitApi()
}

// 必须显式声明
public fun publicFunction(): String = "Hello"  // OK
fun implicitFunction() = "Hello"  // 编译错误

# 3. 尾随逗号

允许在参数列表、数组等末尾添加逗号。

val colors = listOf(
    "红色",
    "绿色",
    "蓝色",  // 尾随逗号
)

fun process(
    first: Int,
    second: Int,
    third: Int,  // 尾随逗号
) { }

# Kotlin/JVM

  • 新的 IR 后端（Beta）：更好的性能和功能
  • 生成默认方法：接口中的非抽象方法编译为 Java 8+ 的默认方法

# 标准库

  • 公共异常类型：kotlin.Exception 等在所有平台可用
  • Appendable.appendLine()：println 的扩展版本
    val sb = StringBuilder()
sb.appendLine("第一行")
sb.appendLine("第二行")

# 1.5（2021年5月）

2021年5月5日发布，带来重要的语言特性。

# 核心特性

# 1. 稳定的 JVM IR 后端

新的 IR（中间表示）后端成为默认选项。

# 2. 密封接口和密封类改进

sealed interface Error
sealed class IOError : Error

class FileReadError(val file: File) : IOError()
class DatabaseError(val source: DataSource) : IOError()

fun handle(error: Error) = when (error) {
    is FileReadError -> println("文件读取错误: ${error.file}")
    is DatabaseError -> println("数据库错误: ${error.source}")
}

# 3. 内联类

用于包装值而不产生额外开销。

@JvmInline
value class Password(private val s: String)

fun login(password: Password) {
    // 运行时，password 直接使用 String，无包装开销
}

# 4. 无符号整数类型稳定

val uint: UInt = 42u
val ulong: ULong = 42uL
val ubyte: UByte = 255u
val ushort: UShort = 65535u

val uintArray = uintArrayOf(1u, 2u, 3u)

# 标准库

  • Locale 无关的大小写转换

    val uppercase = "kotlin".uppercase()  // KOTLIN
val lowercase = "KOTLIN".lowercase()  // kotlin

  • Path 操作（实验性）

    val path = Path("src/main/kotlin")
val absolute = path.absolute()
val normalized = path.normalize()

  • Duration API

    val duration = 5.seconds + 300.milliseconds
println(duration.inWholeMilliseconds)  // 5300

# 1.6（2021年11月）

2021年11月16日发布，继续改进语言特性。

# 核心特性

# 1. 密封 when 语句

不需要 else 分支的穷尽性检查。

sealed class Result
class Success(val data: String) : Result()
class Error(val message: String) : Result()

fun handle(result: Result) {
    when (result) {  // 不需要 else
        is Success -> println(result.data)
        is Error -> println(result.message)
    }
}

# 2. 注解类实例化

annotation class InfoMarker(val info: String)

fun processAnnotations() {
    val marker = InfoMarker("示例")
    println(marker.info)
}

# 3. 可选的 expect 声明

expect class Optional<T> {
    val value: T?
}

// 平台代码可以省略该声明

# Kotlin/JVM

  • 默认情况下递归生成目录
  • 优化委托属性：生成更少的字节码

# 标准库

  • 稳定的类型安全构建器
  • 稳定的 Duration API
  • 集合构建器稳定
    val list = buildList {
    add(1)
    add(2)
    addAll(listOf(3, 4, 5))
}

# 1.7（2022年6月）

2022年6月9日发布，引入 K2 编译器 Alpha 版。

# 核心特性

# 1. K2 编译器 Alpha

新一代编译器架构，提升编译速度和分析能力。

# 2. 稳定的构建器推断

fun <T> buildList(builderAction: MutableList<T>.() -> Unit): List<T> {
    return ArrayList<T>().apply(builderAction)
}

val result = buildList {
    add("Hello")
    add("World")
    // 编译器推断类型为 String
}

# 3. opt-in 要求提升为错误

@RequiresOptIn
annotation class ExperimentalApi

@ExperimentalApi
class ExperimentalClass

// 必须添加 @OptIn 才能使用
@OptIn(ExperimentalApi::class)
fun useExperimental() {
    ExperimentalClass()
}

# Kotlin/JVM

  • 支持 Java 18
  • Java 8+ 目标优化

# Kotlin/Native

  • 新的内存管理器默认启用
  • 性能改进：对象分配速度提升

# 1.8（2022年12月）

2022年12月28日发布，继续完善编译器和工具链。

# 核心特性

# 1. 改进的递归泛型

fun <T : Comparable<T>> List<T>.quickSort(): List<T> =
    if (size < 2) this
    else {
        val pivot = first()
        val (smaller, greater) = drop(1).partition { it < pivot }
        smaller.quickSort() + pivot + greater.quickSort()
    }

# 2. 确定性非空类型

fun <T> processNonNull(value: T & Any) {
    // T & Any 保证非空
    println(value.toString())
}

# Kotlin/Native

  • 新的 Objective-C/Swift 互操作改进
  • CocoaPods 集成优化

# 1.9（2023年7月）

2023年7月6日发布，K2 编译器进入 Beta。

# 核心特性

# 1. K2 编译器 Beta

// gradle.properties
kotlin.experimental.tryK2=true

# 2. 稳定的 enum entries

替代 values() 函数。

enum class Color(val rgb: String) {
    RED("#FF0000"),
    GREEN("#00FF00"),
    BLUE("#0000FF")
}

fun findByRgb(rgb: String): Color? = Color.entries.find { it.rgb == rgb }

# 3. 稳定的 data object

sealed interface ReadResult
data class Number(val number: Int) : ReadResult
data class Text(val text: String) : ReadResult
data object EndOfFile : ReadResult  // 有 toString()

fun process(result: ReadResult) {
    when (result) {
        is Number -> println("数字: ${result.number}")
        is Text -> println("文本: ${result.text}")
        EndOfFile -> println(result)  // 输出: EndOfFile
    }
}

# 4. 内联值类支持带体的次构造函数

@JvmInline
value class Person(private val fullName: String) {
    init {
        require(fullName.isNotBlank()) {
            "Full name shouldn't be empty"
        }
    }
    
    constructor(name: String, lastName: String) : this("$name $lastName") {
        require(lastName.isNotBlank()) {
            "Last name shouldn't be empty"
        }
    }
}

# 标准库

# 稳定的 ..< 操作符

for (number in 2..<10) {
    if (number % 2 == 0) {
        print("$number ")
    }
}
// 输出: 2 4 6 8

# 时间 API 稳定

val timeSource = TimeSource.Monotonic
val mark1 = timeSource.markNow()
Thread.sleep(500)
val mark2 = timeSource.markNow()

val elapsed: Duration = mark2 - mark1
println("耗时: ${elapsed.inWholeMilliseconds}ms")

# 正则表达式增强

val regex = """\b(?<city>[A-Za-z\s]+),\s(?<state>[A-Z]{2})\b""".toRegex()
val match = regex.find("Austin, TX")!!
println(match.groups["city"]?.value)  // Austin
println(match.groups["state"]?.value)  // TX

# Kotlin Multiplatform

  • 稳定版发布：生产环境可用
  • Android target 重命名：androidTarget
  • 改进的 Gradle 配置缓存支持

# 2.0（2024年5月）

2024年5月21日发布，K2 编译器正式稳定。

# 革命性特性

# 1. K2 编译器稳定

  • 2倍编译速度提升
  • 更好的类型推断
  • 改进的智能转换
// 改进的智能转换
val isCat = animal is Cat
if (isCat) {
    animal.purr()  // 自动转换
}

// 逻辑或的类型检查
if (status is Postponed || status is Declined) {
    status.signal()  // 转换为公共父类型
}

// 内联函数中的智能转换
inline fun inlineAction(f: () -> Unit) = f()
var processor: Processor? = null
inlineAction {
    if (processor != null) {
        processor.process()  // 无需安全调用
    }
}

# Kotlin/JVM

# invokedynamic 生成 lambda

默认使用 invokedynamic，减小二进制大小。

// 生成更紧凑的字节码
val lambda = { x: Int -> x * 2 }

# Kotlin/Wasm

# 命名导出

@JsExport
fun add(a: Int, b: Int) = a + b

JavaScript 中使用：

import { add } from "./index.mjs"
console.log(add(2, 3))

# TypeScript 声明生成（实验性）

kotlin {
    wasmJs {
        generateTypeScriptDefinitions()
    }
}

# Kotlin/JS

# ES2015 目标

kotlin {
    js {
        compilerOptions {
            target.set("es2015")
        }
    }
}

# 类型安全的普通对象

@JsPlainObject
external interface User {
    var name: String
    val age: Int
}

val user = User(name = "张三", age = 25)
val copy = user.copy(age = 26)

# 标准库

# enumEntries 函数

inline fun <reified T : Enum<T>> printAllValues() {
    print(enumEntries<T>().joinToString { it.name })
}

# AutoCloseable 接口稳定

class Resource : AutoCloseable {
    override fun close() {
        println("资源已关闭")
    }
}

Resource().use {
    // 使用资源
}  // 自动关闭

# 2.1（2024年11月）

2024年11月27日发布，引入新的语言特性预览。

# 语言特性（预览）

# 1. when 表达式的守卫条件

sealed interface Animal {
    data class Cat(val mouseHunter: Boolean) : Animal
    data class Dog(val breed: String) : Animal
}

fun feedAnimal(animal: Animal) {
    when (animal) {
        is Animal.Dog -> animal.feedDog()
        is Animal.Cat if !animal.mouseHunter -> animal.feedCat()
        else -> println("未知动物")
    }
}

启用方式：

kotlin {
    compilerOptions {
        freeCompilerArgs.add("-Xwhen-guards")
    }
}

# 2. 非局部 break 和 continue

fun processList(elements: List<Int>): Boolean {
    for (element in elements) {
        val variable = element.nullableMethod() ?: run {
            log.warning("元素无效，继续...")
            continue  // 非局部 continue
        }
        if (variable == 0) return true
    }
    return false
}

# 3. 多美元符号字符串插值

用于包含大量 $ 符号的字符串。

val KClass<*>.jsonSchema: String
    get() = $$"""
    {
      "$schema": "https://json-schema.org/draft/2020-12/schema",
      "$id": "https://example.com/product.schema.json",
      "title": "$${simpleName ?: qualifiedName ?: "unknown"}",
      "type": "object"
    }
    """

# Kotlin Multiplatform

# Swift 导出基础支持（实验性）

kotlin {
    iosX64()
    iosArm64()
    iosSimulatorArm64()

    @OptIn(ExperimentalSwiftExportDsl::class)
    swiftExport {
        moduleName = "Shared"
        flattenPackage = "com.example.sandbox"
    }
}

# Kotlin/Wasm

# JavaScript 数组互操作

val list: List<JsString> = listOf("Kotlin", "Wasm").map { it.toJsString() }
val jsArray: JsArray<JsString> = list.toJsArray()
val kotlinArray: Array<JsString> = jsArray.toArray()
val kotlinList: List<JsString> = jsArray.toList()

# 标准库

# 文件树遍历（稳定）

val cleanVisitor = fileVisitor {
    onPreVisitDirectory { directory, _ ->
        if (directory.name == "build") {
            directory.toFile().deleteRecursively()
            FileVisitResult.SKIP_SUBTREE
        } else {
            FileVisitResult.CONTINUE
        }
    }
    
    onVisitFile { file, _ ->
        if (file.extension == "class") {
            file.deleteExisting()
        }
        FileVisitResult.CONTINUE
    }
}

rootDirectory.visitFileTree(cleanVisitor)

# 2.2（2024年12月）

2024年12月发布，包含多个实验性特性。

# 语言特性（预览）

# 1. 上下文参数（Context Parameters）

允许函数声明隐式依赖。

interface UserService {
    fun log(message: String)
    fun findUserById(id: Int): String
}

context(users: UserService)
fun outputMessage(message: String) {
    users.log("Log: $message")
}

context(users: UserService)
val firstUser: String
    get() = users.findUserById(1)

启用方式：

-Xcontext-parameters

# 2. 上下文敏感解析

在已知类型的上下文中省略类型名。

enum class Problem {
    CONNECTION, AUTHENTICATION, DATABASE, UNKNOWN
}

fun message(problem: Problem): String = when (problem) {
    CONNECTION -> "连接问题"
    AUTHENTICATION -> "认证问题"
    DATABASE -> "数据库问题"
    UNKNOWN -> "未知问题"
}

# 3. @all 元注解目标

简化属性注解。

data class User(
    val username: String,
    @all:Email val email: String,  // 应用到所有目标
) {
    @all:Email val secondaryEmail: String? = null
}

# 4. 嵌套类型别名（Beta）

class Dijkstra {
    typealias VisitedNodes = Set<Node>
    
    private fun step(visited: VisitedNodes, ...) { }
}

# Kotlin/JVM

# @JvmExposeBoxed 注解（实验性）

改进内联值类的 Java 互操作。

@JvmExposeBoxed
@JvmInline
value class MyInt(val value: Int)

@JvmExposeBoxed
fun MyInt.timesTwoBoxed(): MyInt = MyInt(this.value * 2)

Java 中使用：

MyInt input = new MyInt(5);
MyInt output = ExampleKt.timesTwoBoxed(input);
System.out.println(output.getValue());  // 10

# Kotlin/Native

# 按对象分配内存（实验性）

kotlin.native.binary.pagedAllocator=false

# Latin-1 编码字符串（实验性）

kotlin.native.binary.latin1Strings=true

# LLVM 更新

从版本 16 升级到 19。

# 标准库

# Base64 API（稳定）

val bytes = "Hello World".encodeToByteArray()
val encoded = Base64.Default.encode(bytes)
println(encoded)  // SGVsbG8gV29ybGQ=

val decoded = Base64.Default.decode(encoded)
println(decoded.decodeToString())  // Hello World

// 不同编码方案
Base64.Default      // 标准 Base64
Base64.UrlSafe      // URL 安全
Base64.Mime         // MIME 格式
Base64.Pem          // PEM 格式（新增）

// JVM 流支持
val output = ByteArrayOutputStream()
val base64Output = output.encodingWith(Base64.Default)
base64Output.use { stream ->
    stream.write("Hello!!".encodeToByteArray())
}
println(output.toString())  // SGVsbG8hIQ==

# HexFormat API（稳定）

println(93.toHexString())  // 5d

val format = HexFormat {
    upperCase = true
    bytes.byteSeparator = ":"
}
val bytes = byteArrayOf(0xAB.toByte(), 0xCD.toByte())
println(bytes.toHexString(format))  // AB:CD

# Gradle

# 二进制兼容性验证（实验性）

kotlin {
    @OptIn(ExperimentalAbiValidation::class)
    abiValidation {
        enabled.set(true)
        filters.excluded.byNames.add("com.company.**")
    }
}

检查和更新：

./gradlew checkLegacyAbi
./gradlew updateLegacyAbi

# 总结

Kotlin 从2016年发布至今，已经发展成为一门成熟、强大的现代编程语言：

  • 1.0（2016）：稳定发布，奠定基础
  • 1.1（2017）：协程、类型别名，异步编程支持
  • 1.3（2018）：协程稳定，多平台项目重构
  • 1.5（2021）：密封接口、内联类，JVM IR 后端稳定
  • 1.9（2023）：K2 编译器 Beta，Kotlin Multiplatform 稳定
  • 2.0（2024）：K2 编译器稳定，性能大幅提升
  • 2.2（2024）：上下文参数、Base64 API，持续创新

重点关注的版本：

  • 1.0：Kotlin 基础，必须掌握
  • 1.1：协程引入，异步编程革命
  • 1.3：协程稳定，多平台支持成熟
  • 2.0：K2 编译器，性能和功能全面升级

Kotlin 的设计哲学：

  • 简洁务实：减少样板代码，提高开发效率
  • 安全可靠：空安全、类型安全，编译时发现错误
  • 互操作性：与 Java 无缝集成，渐进式迁移
  • 多平台愿景：一套代码，多端运行

# 参考资料

祝你变得更强!

编辑 (opens new window)
#Kotlin版本新特性#Kotlin
上次更新: 2025/11/07
Java开发者转战Python：生态与质量管理
从Eclipse到IDEA，金字塔到太空堡垒

← 从Eclipse到IDEA，金字塔到太空堡垒→

最近更新
01
AI编程时代的一些心得
09-11
02
Claude Code与Codex的协同工作
09-01
03
Claude Code 最佳实践（个人版）
08-01
更多文章>
Theme by Vdoing | Copyright © 2018-2025 京ICP备2021021832号-2 | MIT License