让我为你详细解释每个部分：
-
变量声明
-
val声明不可变变量（一旦赋值不能改变） -
var声明可变变量（可以重新赋值） - Kotlin 支持类型推断，可以省略类型声明
- 变量必须初始化，除非明确声明为可空类型
-
-
基本数据类型
- Kotlin 中一切皆对象，没有原始类型
- 常用数据类型：Byte, Short, Int, Long, Float, Double, Boolean, Char
- 每种类型都有自己的取值范围
- 数字类型支持下划线提高可读性：
val million = 1_000_000
-
字符串
- 使用双引号声明普通字符串
- 使用三个双引号声明多行字符串
- 支持字符串模板：使用
$或${}插入变量或表达式 - 支持字符串操作：拼接、截取、替换等
-
条件表达式
-
if在 Kotlin 中是表达式，可以返回值 -
when表达式替代了 Java 的 switch，更强大灵活 - 支持多条件匹配和类型检查
-
-
空安全
- 默认情况下变量不能为 null
- 使用
?声明可空类型 - 使用
?.安全调用 - 使用
?:(Elvis 操作符) 提供默认值 - 使用
!!强制非空（不推荐使用）
-
循环控制
-
for循环支持区间遍历 - 支持递增/递减范围
- 支持指定步长
-
while和do-while循环与 Java 类似
-
-
函数
- 使用
fun关键字声明函数 - 支持单表达式函数简写
- 支持默认参数值
- 支持命名参数调用
- 返回类型在参数列表后面声明
- 使用
-
集合
- 区分可变集合和不可变集合
- 常用集合类型：List、Set、Map
- 提供丰富的集合操作函数
- 支持序列操作提高性能
-
数组
- 使用 Array 类表示数组
- 提供专门的基本类型数组：IntArray、CharArray 等
- 支持数组初始化器
- 支持数组操作函数
// 1. 变量声明
// val 声明不可变变量（类似Java的final）
val immutableVar: String = "This can't be changed"
// var 声明可变变量
var mutableVar: Int = 42
mutableVar = 43 // 可以修改
// 类型推断
val inferredString = "Kotlin will know this is a String"
val inferredInt = 100 // Kotlin will know this is an Int
// 2. 基本数据类型
val myByte: Byte = 127
val myShort: Short = 32767
val myInt: Int = 123456
val myLong: Long = 123456789L
val myFloat: Float = 3.14f
val myDouble: Double = 3.14159
val myBoolean: Boolean = true
val myChar: Char = 'A'
// 3. 字符串
val simpleString = "Hello"
// 字符串模板
val name = "Kotlin"
val greeting = "Hello, $name!"
// 多行字符串
val multilineString = """
This is a multi-line
string in Kotlin.
No need for escape characters.
""".trimIndent()
// 4. 条件表达式
fun maxOf(a: Int, b: Int): Int {
// if 作为表达式
return if (a > b) {
a
} else {
b
}
}
// when 表达式（类似switch，但更强大）
fun describe(obj: Any): String =
when (obj) {
1 -> "One"
"Hello" -> "Greeting"
is Long -> "Long number"
!is String -> "Not a string"
else -> "Unknown"
}
// 5. 空安全
// 可空类型声明
var nullableString: String? = "Hello"
nullableString = null // 合法
// 安全调用操作符
val length = nullableString?.length // 如果nullableString为null，则length为null
// Elvis操作符
val nonNullLength = nullableString?.length ?: 0 // 如果nullableString为null，则使用默认值0
// 6. 循环
fun loops() {
// for循环
for (i in 1..5) {
println(i) // 打印1到5
}
// 区间
val range = 1..5 // 包含5
val rangeExclusive = 1 until 5 // 不包含5
val downRange = 5 downTo 1 // 递减
val stepRange = 1..10 step 2 // 步长为2
// 遍历数组/列表
val items = listOf("apple", "banana", "orange")
for (item in items) {
println(item)
}
// while循环
var x = 5
while (x > 0) {
println(x)
x--
}
// do-while循环
do {
println("At least once")
} while (false)
}
// 7. 函数
// 简单函数声明
fun sum(a: Int, b: Int): Int {
return a + b
}
// 单表达式函数
fun multiply(a: Int, b: Int) = a * b
// 默认参数
fun greet(name: String = "World") = "Hello, $name!"
// 命名参数
fun reformat(
str: String,
normalizeCase: Boolean = true,
upperCaseFirstLetter: Boolean = true,
divideByCamelHumps: Boolean = false,
wordSeparator: Char = ' '
) {
// 函数实现
}
// 8. 集合
fun collections() {
// 不可变List
val readOnlyList = listOf("a", "b", "c")
// 可变List
val mutableList = mutableListOf("a", "b", "c")
mutableList.add("d")
// Set
val readOnlySet = setOf("a", "b", "c")
val mutableSet = mutableSetOf("a", "b", "c")
// Map
val readOnlyMap = mapOf("a" to 1, "b" to 2, "c" to 3)
val mutableMap = mutableMapOf("a" to 1, "b" to 2)
}
// 9. 数组
fun arrays() {
// 创建数组
val numbers = Array(5) { it * 2 } // [0, 2, 4, 6, 8]
// 基本类型数组
val intArray = IntArray(5) // [0, 0, 0, 0, 0]
val charArray = CharArray(3) { 'a' + it } // ['a', 'b', 'c']
}
// 10. 主函数示例
fun main() {
println(greeting) // 使用之前定义的greeting变量
println(maxOf(4, 2)) // 调用maxOf函数
println(describe(1)) // 调用describe函数
println(greet()) // 使用默认参数
println(greet("Kotlin")) // 传入参数
// 使用命名参数调用reformat
reformat(
"hello",
upperCaseFirstLetter = false,
wordSeparator = '_'
)
// 演示循环
loops()
// 演示集合操作
collections()
}
-
if 表达式
- Kotlin 中的 if 是表达式，可以返回值
- 可以替代三元运算符 (?:)
- 支持多行代码块，最后一行作为返回值
- 可以用于变量赋值
-
when 表达式的特点：
- 替代了 Java 的 switch 语句
- 更强大、更灵活
- 可以处理任何类型的数据
- 支持多种匹配方式：
- 具体值匹配
- 类型匹配
- 区间匹配
- 多值匹配
- 无参数条件判断
-
智能类型转换
- 在条件判断后自动转换类型
- 减少显式类型转换
- 提高代码可读性和安全性
-
条件判断的最佳实践：
- 优先使用 when 代替复杂的 if-else 链
- 利用表达式特性简化代码
- 合理使用区间检查
- 善用类型检查和智能转换
-
性能考虑：
- when 表达式会被编译成高效的字节码
- 编译器会优化分支判断
- 对于简单判断，if 和 when 性能相似
// 1. 变量声明
// val 声明不可变变量（类似Java的final）
val immutableVar: String = "This can't be changed"
// var 声明可变变量
var mutableVar: Int = 42
mutableVar = 43 // 可以修改
// 类型推断
val inferredString = "Kotlin will know this is a String"
val inferredInt = 100 // Kotlin will know this is an Int
// 2. 基本数据类型
val myByte: Byte = 127
val myShort: Short = 32767
val myInt: Int = 123456
val myLong: Long = 123456789L
val myFloat: Float = 3.14f
val myDouble: Double = 3.14159
val myBoolean: Boolean = true
val myChar: Char = 'A'
// 3. 字符串
val simpleString = "Hello"
// 字符串模板
val name = "Kotlin"
val greeting = "Hello, $name!"
// 多行字符串
val multilineString = """
This is a multi-line
string in Kotlin.
No need for escape characters.
""".trimIndent()
// 4. 条件表达式
fun maxOf(a: Int, b: Int): Int {
// if 作为表达式
return if (a > b) {
a
} else {
b
}
}
// when 表达式（类似switch，但更强大）
fun describe(obj: Any): String =
when (obj) {
1 -> "One"
"Hello" -> "Greeting"
is Long -> "Long number"
!is String -> "Not a string"
else -> "Unknown"
}
// 5. 空安全
// 可空类型声明
var nullableString: String? = "Hello"
nullableString = null // 合法
// 安全调用操作符
val length = nullableString?.length // 如果nullableString为null，则length为null
// Elvis操作符
val nonNullLength = nullableString?.length ?: 0 // 如果nullableString为null，则使用默认值0
// 6. 循环
fun loops() {
// for循环
for (i in 1..5) {
println(i) // 打印1到5
}
// 区间
val range = 1..5 // 包含5
val rangeExclusive = 1 until 5 // 不包含5
val downRange = 5 downTo 1 // 递减
val stepRange = 1..10 step 2 // 步长为2
// 遍历数组/列表
val items = listOf("apple", "banana", "orange")
for (item in items) {
println(item)
}
// while循环
var x = 5
while (x > 0) {
println(x)
x--
}
// do-while循环
do {
println("At least once")
} while (false)
}
// 7. 函数
// 简单函数声明
fun sum(a: Int, b: Int): Int {
return a + b
}
// 单表达式函数
fun multiply(a: Int, b: Int) = a * b
// 默认参数
fun greet(name: String = "World") = "Hello, $name!"
// 命名参数
fun reformat(
str: String,
normalizeCase: Boolean = true,
upperCaseFirstLetter: Boolean = true,
divideByCamelHumps: Boolean = false,
wordSeparator: Char = ' '
) {
// 函数实现
}
// 8. 集合
fun collections() {
// 不可变List
val readOnlyList = listOf("a", "b", "c")
// 可变List
val mutableList = mutableListOf("a", "b", "c")
mutableList.add("d")
// Set
val readOnlySet = setOf("a", "b", "c")
val mutableSet = mutableSetOf("a", "b", "c")
// Map
val readOnlyMap = mapOf("a" to 1, "b" to 2, "c" to 3)
val mutableMap = mutableMapOf("a" to 1, "b" to 2)
}
// 9. 数组
fun arrays() {
// 创建数组
val numbers = Array(5) { it * 2 } // [0, 2, 4, 6, 8]
// 基本类型数组
val intArray = IntArray(5) // [0, 0, 0, 0, 0]
val charArray = CharArray(3) { 'a' + it } // ['a', 'b', 'c']
}
// 10. 主函数示例
fun main() {
println(greeting) // 使用之前定义的greeting变量
println(maxOf(4, 2)) // 调用maxOf函数
println(describe(1)) // 调用describe函数
println(greet()) // 使用默认参数
println(greet("Kotlin")) // 传入参数
// 使用命名参数调用reformat
reformat(
"hello",
upperCaseFirstLetter = false,
wordSeparator = '_'
)
// 演示循环
loops()
// 演示集合操作
collections()
}
-
高阶函数的特点：
- 可以接收函数作为参数
- 可以返回函数
- 支持函数类型的变量
- 可以使用 lambda 表达式简化代码
-
Lambda 表达式：
- 是匿名函数
- 可以存储在变量中
- 可以作为参数传递
- 最后一个表达式是返回值
-
常用集合操作符：
a. 转换操作：
- map：转换每个元素
- flatMap：转换并展平结果
- mapNotNull：转换并过滤空值
b. 过滤操作：
- filter：按条件过滤
- filterNot：取反过滤
- take/drop：取或跳过前N个元素
c. 聚合操作：
- reduce：归约操作
- fold：带初始值的归约
- groupBy：分组操作
d. 其他操作：
- distinct：去重
- sorted：排序
- partition：分区
-
作用域函数：
- let：处理可空对象
- with：对同一个对象执行多个操作
- run：初始化并计算结果
- apply：对象配置
- also：额外操作
-
序列操作的优势：
- 惰性求值
- 中间操作不会立即执行
- 适合大数据量处理
- 提高性能
-
内联函数：
- 减少函数调用开销
- 适合小型、频繁调用的函数
- 编译时展开代码
使用建议：
-
选择合适的集合操作符：
- 使用 map 进行简单转换
- 使用 filter 进行条件筛选
- 使用 reduce/fold 进行累积操作
- 考虑使用序列处理大量数据
-
高阶函数使用技巧：
- 合理使用类型推断
- 善用 lambda 表达式简化代码
- 适当使用作用域函数提高可读性
- 注意内存和性能影响
-
性能优化：
- 使用序列避免中间集合
- 合理使用内联函数
- 避免过度使用高阶函数
- 注意闭包捕获变量的影响
// 1. 基本的高阶函数示例
// 接收一个函数作为参数
fun calculate(x: Int, y: Int, operation: (Int, Int) -> Int): Int {
return operation(x, y)
}
// 返回一个函数
fun getOperation(operator: String): (Int, Int) -> Int {
return when (operator) {
"+" -> { a, b -> a + b }
"-" -> { a, b -> a - b }
"*" -> { a, b -> a * b }
"/" -> { a, b -> a / b }
else -> { _, _ -> 0 }
}
}
// 2. 使用lambda表达式
val sum = { x: Int, y: Int -> x + y }
val multiply = { x: Int, y: Int -> x * y }
// 3. 函数类型与nullable
var nullableFunction: ((Int, Int) -> Int)? = null
// 4. 带接收者的函数类型
class HTML {
fun body() { println("body") }
}
fun HTML.init(action: HTML.() -> Unit) {
action()
}
// 5. 集合操作示例
fun collectionOperations() {
val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
val words = listOf("apple", "banana", "cherry", "date")
// map转换
val doubled = numbers.map { it * 2 }
println("Doubled numbers: $doubled")
// filter过滤
val evenNumbers = numbers.filter { it % 2 == 0 }
println("Even numbers: $evenNumbers")
// flatMap展平
val letters = words.flatMap { it.toList() }
println("All letters: $letters")
// reduce归约
val sum = numbers.reduce { acc, num -> acc + num }
println("Sum: $sum")
// fold带初始值归约
val sumWithInitial = numbers.fold(100) { acc, num -> acc + num }
println("Sum with initial: $sumWithInitial")
// take和drop
val firstThree = numbers.take(3)
val skipThree = numbers.drop(3)
println("First three: $firstThree")
println("Skip three: $skipThree")
// distinct去重
val duplicates = listOf(1, 1, 2, 2, 3, 3)
val unique = duplicates.distinct()
println("Unique numbers: $unique")
// groupBy分组
val groupByLength = words.groupBy { it.length }
println("Grouped by length: $groupByLength")
// partition分区
val (evens, odds) = numbers.partition { it % 2 == 0 }
println("Evens: $evens")
println("Odds: $odds")
}
// 6. 序列操作
fun sequenceOperations() {
val numbers = generateSequence(1) { it + 1 }
.take(10)
.filter { it % 2 == 0 }
.map { it * it }
.toList()
println("Sequence result: $numbers")
}
// 7. 自定义高阶函数
fun <T> List<T>.customFilter(predicate: (T) -> Boolean): List<T> {
val result = mutableListOf<T>()
for (item in this) {
if (predicate(item)) {
result.add(item)
}
}
return result
}
// 8. 作用域函数
fun scopeFunctions() {
// let
val str: String? = "Hello"
str?.let {
println("Length is ${it.length}")
}
// with
val numbers = mutableListOf<Int>()
with(numbers) {
add(1)
add(2)
add(3)
}
// run
val result = "Hello".run {
println("Original string: $this")
uppercase()
}
// apply
val list = mutableListOf<Int>().apply {
add(1)
add(2)
add(3)
}
// also
list.also {
println("List size: ${it.size}")
}
}
// 9. 内联函数示例
inline fun measureTime(action: () -> Unit): Long {
val startTime = System.currentTimeMillis()
action()
return System.currentTimeMillis() - startTime
}
// 10. 主函数：展示各种用法
fun main() {
// 基本高阶函数使用
println(calculate(10, 5) { x, y -> x + y })
println(calculate(10, 5, getOperation("*")))
// Lambda表达式使用
println(sum(5, 3))
println(multiply(4, 2))
// 集合操作
collectionOperations()
// 序列操作
sequenceOperations()
// 自定义高阶函数使用
val numbers = listOf(1, 2, 3, 4, 5)
val filtered = numbers.customFilter { it > 3 }
println("Custom filtered: $filtered")
// 作用域函数
scopeFunctions()
// 测量执行时间
val time = measureTime {
Thread.sleep(100)
}
println("Execution time: $time ms")
}
-
协程：
- 轻量级线程
- 主要特点：
- 非阻塞异步编程
- 结构化并发
- 取消和异常处理
- 关键组件：
- coroutineScope：协程作用域
- launch：启动协程
- async：带返回值的协程
- Dispatchers：调度器
-
范围函数：
- let：处理可空对象，作用域限定
- run：对象配置和计算结果
- with：对同一对象进行多次操作
- apply：对象配置，返回对象本身
- also：附加操作，返回对象本身
-
类型系统：
- 泛型：
- 类型参数
- 泛型约束
- 泛型函数
- 型变：
- 协变（out）：生产者
- 逆变（in）：消费者
- 不变：默认
- 泛型：
-
操作符重载：
- 算术运算符：plus、minus等
- 一元运算符：unaryPlus、unaryMinus
- 比较运算符：compareTo
- 索引访问：get、set
- 调用运算符：invoke
-
内联函数：
- 减少函数调用开销
- 适用场景：
- 高阶函数
- Lambda表达式
- 属性访问器
- 特点：
- 编译时代码展开
- 支持具体化类型参数
-
注解：
- 元数据标记
- 用途：
- 编译时处理
- 运行时反射
- 代码生成
- 特点：
- 可自定义目标
- 可指定保留期
- 支持参数
使用建议：
-
协程使用：
- 合理选择调度器
- 注意异常处理
- 正确管理生命周期
- 使用结构化并发
-
范围函数选择：
- let：处理可空值
- run：对象初始化和转换
- with：多次操作同一对象
- apply：对象配置
- also：附加效果
-
类型系统：
- 合理使用泛型约束
- 正确选择型变修饰符
- 注意类型擦除
-
操作符重载：
- 保持语义一致性
- 避免过度使用
- 注意性能影响
import kotlinx.coroutines.*
// 1. 协程基础
class CoroutinesExample {
// 基本协程构建器
suspend fun basicCoroutine() {
coroutineScope {
launch {
delay(1000L)
println("World!")
}
print("Hello, ")
}
}
// 并行执行
suspend fun parallelExecution() = coroutineScope {
val job1 = launch {
delay(1000L)
println("Job1 完成")
}
val job2 = launch {
delay(800L)
println("Job2 完成")
}
job1.join()
job2.join()
}
// 使用 async 获取返回值
suspend fun asyncExample() = coroutineScope {
val deferred1 = async {
delay(1000L)
"结果1"
}
val deferred2 = async {
delay(800L)
"结果2"
}
println("${deferred1.await()} + ${deferred2.await()}")
}
// 协程上下文和调度器
fun dispatcherExample() = runBlocking {
launch(Dispatchers.Default) {
// CPU 密集型操作
println("运行在默认调度器")
}
launch(Dispatchers.IO) {
// IO 操作
println("运行在 IO 调度器")
}
launch(Dispatchers.Main) {
// UI 操作 (在Android环境中)
println("运行在主线程")
}
}
// 协程作用域
class MyScope : CoroutineScope {
private val job = Job()
override val coroutineContext = job + Dispatchers.Default
fun doWork() = launch {
// 在作用域内启动协程
}
fun cleanup() {
job.cancel() // 取消所有协程
}
}
}
// 2. 范围函数
class ScopeFunctionsExample {
data class Person(
var name: String = "",
var age: Int = 0,
var city: String = ""
)
fun letExample() {
val str: String? = "Hello"
// let 用于非空判断和作用域限定
str?.let {
println("长度是 ${it.length}")
}
}
fun runExample() {
val person = Person()
// run 用于初始化和计算结果
val result = person.run {
name = "John"
age = 20
"初始化完成: $name is $age" // 返回值
}
}
fun withExample() {
val person = Person()
// with 用于对同一个对象进行多次操作
with(person) {
name = "John"
age = 20
city = "New York"
}
}
fun applyExample() {
// apply 用于对象配置，返回对象本身
val person = Person().apply {
name = "John"
age = 20
city = "New York"
}
}
fun alsoExample() {
// also 用于附加操作，返回对象本身
Person()
.also { println("创建对象: $it") }
.also { it.name = "John" }
.also { println("设置名字: ${it.name}") }
}
}
// 3. 类型系统
// 泛型类
class Box<T>(private var value: T) {
fun getValue(): T = value
fun setValue(newValue: T) {
value = newValue
}
}
// 型变示例
// 协变 (out) - 生产者
interface Source<out T> {
fun get(): T
}
// 逆变 (in) - 消费者
interface Sink<in T> {
fun process(value: T)
}
// 泛型约束
fun <T : Comparable<T>> sort(list: List<T>) {
// 实现排序
}
// 4. 操作符重载
data class Point(val x: Int, val y: Int) {
// 重载加法操作符
operator fun plus(other: Point) = Point(x + other.x, y + other.y)
// 重载减法操作符
operator fun minus(other: Point) = Point(x - other.x, y - other.y)
// 重载一元操作符
operator fun unaryMinus() = Point(-x, -y)
// 重载比较操作符
operator fun compareTo(other: Point): Int =
when {
x != other.x -> x.compareTo(other.x)
else -> y.compareTo(other.y)
}
// 重载索引访问操作符
operator fun get(index: Int): Int =
when(index) {
0 -> x
1 -> y
else -> throw IndexOutOfBoundsException()
}
}
// 5. 内联函数
inline fun measureTime(block: () -> Unit): Long {
val start = System.currentTimeMillis()
block()
return System.currentTimeMillis() - start
}
// 内联属性
inline val currentTime: Long
get() = System.currentTimeMillis()
// 具体化类型参数
inline fun <reified T> isType(value: Any) = value is T
// 6. 注解
@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.RUNTIME)
annotation class Table(val name: String)
@Target(AnnotationTarget.PROPERTY)
@Retention(AnnotationRetention.RUNTIME)
annotation class Column(val name: String = "")
// 注解使用示例
@Table("users")
data class User(
@Column("user_id") val id: Int,
@Column("user_name") val name: String,
@Column val email: String // 使用默认名称
)
// 主函数：展示各种功能
suspend fun main() {
// 1. 协程示例
val coroutinesExample = CoroutinesExample()
coroutinesExample.basicCoroutine()
coroutinesExample.parallelExecution()
coroutinesExample.asyncExample()
// 2. 范围函数示例
val scopeFunctions = ScopeFunctionsExample()
scopeFunctions.letExample()
scopeFunctions.runExample()
scopeFunctions.withExample()
scopeFunctions.applyExample()
scopeFunctions.alsoExample()
// 3. 泛型示例
val box = Box("Hello")
println(box.getValue())
// 4. 操作符重载示例
val p1 = Point(10, 20)
val p2 = Point(30, 40)
println(p1 + p2)
println(-p1)
println(p1[0]) // 访问 x 坐标
// 5. 内联函数示例
val time = measureTime {
Thread.sleep(100)
}
println("执行时间: $time ms")
// 具体化类型参数示例
println(isType<String>("Hello")) // true
println(isType<Int>("Hello")) // false
}
网友评论