Kotlin 习题集 · 基础篇

Kotlin 习题集 · 基础篇

学习 Kotlin 从变量、函数、控制流开始，覆盖核心语法知识点。

---

第一章 变量与数据类型

1.1 val 与 var 的区别

题目： 定义一个不可变变量 name，值为 "Kotlin"，再定义一个可变变量 age，值为 25，并打印输出。

答案：

fun main() {
    val name = "Kotlin"
    var age = 25
    println("Name: $name, Age: $age")
    
    age = 26 // 可以修改
    // name = "Java" // 编译错误，val 不可修改
    println("Updated Age: $age")
}

---

1.2 类型推导与显式声明

题目： 推断以下变量的类型，并写出显式声明版本的代码。

val a = 42          // Int
val b = 3.14         // Double
val c = true         // Boolean
val d = 'K'          // Char
val e = "Hello"      // String
val f = listOf(1, 2) // List<Int>

答案：

val a: Int = 42
val b: Double = 3.14
val c: Boolean = true
val d: Char = 'K'
val e: String = "Hello"
val f: List<Int> = listOf(1, 2)

---

1.3 常量与编译期常量

题目： 定义一个编译期常量 MAX_SIZE，用于表示数组最大长度，并说明它与 val 的区别。

答案：

const val MAX_SIZE = 1000  // 编译期常量，编译时替换为字面量

fun main() {
    val dynamicVal = "runtime"  // 运行时常量
    
    println("MAX_SIZE = $MAX_SIZE")
    // const val 适用于基本类型和 String，且必须在 top-level 或 object 中定义
}

关键区别：

特性	val	const val
求值时机	运行时	编译时
使用场景	动态计算的值	固定不变的值
适用位置	任意位置	top-level 或 object/companion object 内

---

第二章 函数

2.1 基本函数定义

题目： 定义一个函数 greet，接受 String 类型的 name 参数，返回 "Hello, $name!"。

答案：

fun greet(name: String): String {
    return "Hello, $name!"
}

// 单表达式函数可以简写
fun greetShort(name: String) = "Hello, $name!"

fun main() {
    println(greet("Kotlin"))        // Hello, Kotlin!
    println(greetShort("World"))   // Hello, World!
}

---

2.2 默认参数与命名参数

题目： 定义一个函数 createUser，参数：name（必填）、age 默认 18、isActive 默认 true，调用时使用命名参数。

答案：

fun createUser(name: String, age: Int = 18, isActive: Boolean = true): String {
    return "User($name, age=$age, active=$isActive)"
}

fun main() {
    // 使用命名参数，简化调用
    println(createUser(name = "Alice"))  // User(Alice, age=18, active=true)
    println(createUser(name = "Bob", age = 25))  // User(Bob, age=25, active=true)
    println(createUser(name = "Carol", isActive = false))  // User(Carol, age=18, active=false)
}

---

2.3 可变参数

题目： 定义函数 sum，接受任意数量的 Int 参数，返回它们的和。

答案：

fun sum(vararg numbers: Int): Int {
    return numbers.sum()
}

fun main() {
    println(sum(1, 2, 3))           // 6
    println(sum(10, 20, 30, 40))     // 100
    println(sum())                   // 0
    
    val arr = intArrayOf(5, 5, 5)
    println(sum(*arr))               // 展开数组传参：15
}

---

2.4 特殊返回类型 Unit

题目： 定义一个无返回值的函数 printAll，打印所有传入的字符串，观察 Unit 的用法。

答案：

fun printAll(vararg items: String): Unit {
    items.forEach { println(it) }
}

// Unit 可以省略不写
fun printAllShort(vararg items: String) {
    items.forEach { println(it) }
}

fun main() {
    val result: Unit = printAll("A", "B", "C")
    println("Return value: $result")  // kotlin.Unit
}

---

第三章 控制流

3.1 if 表达式

题目： 定义函数 maxOf，返回两个 Int 中的最大值，用 if 表达式实现。

答案：

fun maxOf(a: Int, b: Int): Int {
    return if (a > b) a else b
}

// 更简洁的写法
fun maxOfShort(a: Int, b: Int) = if (a > b) a else b

fun main() {
    println(maxOf(10, 20))   // 20
    println(maxOf(50, 30))   // 50
}

---

3.2 when 表达式（基础）

题目： 定义函数 describe，接受任意类型参数，返回描述字符串：

• 数字类型 → "数字: $n"
• 字符串 → "字符串: s ( 长度 = s (长度= s(长度={s.length})"
• 布尔值 → "布尔值: $b"
• 其他 → "未知类型"

答案：

fun describe(obj: Any): String = when (obj) {
    is Int -> "数字: $obj"
    is String -> "字符串: $obj (长度=${obj.length})"
    is Boolean -> "布尔值: $obj"
    else -> "未知类型"
}

fun main() {
    println(describe(42))          // 数字: 42
    println(describe("Hello"))    // 字符串: Hello (长度=5)
    println(describe(true))       // 布尔值: true
    println(describe(listOf(1)))  // 未知类型
}

---

3.3 when 区间与条件

题目： 定义函数 grade，根据分数返回等级：

• >=90 → "A"
• 80-89 → "B"
• 60-79 → "C"
• <60 → "D"

答案：

fun grade(score: Int): String = when {
    score >= 90 -> "A"
    score in 80..89 -> "B"
    score in 60..79 -> "C"
    else -> "D"
}

fun main() {
    println(grade(95))   // A
    println(grade(85))   // B
    println(grade(70))   // C
    println(grade(50))   // D
}

---

3.4 for 循环

题目： 用 for 循环实现：

1. 打印 1 到 10
2. 遍历列表 ["Kotlin", "Java", "Go"]
3. 遍历 1-100 中所有偶数

答案：

fun main() {
    // 1. 打印 1 到 10
    for (i in 1..10) {
        print("$i ")
    }
    println()
    
    // 2. 遍历列表
    for (lang in listOf("Kotlin", "Java", "Go")) {
        println(lang)
    }
    
    // 3. 遍历偶数
    for (i in 2..100 step 2) {
        print("$i ")
    }
}

---

3.5 while 与 do-while

题目： 使用 while 计算 1 + 2 + ... + n 的和，直到和超过 100。

答案：

fun main() {
    var sum = 0
    var n = 1
    while (sum <= 100) {
        sum += n
        n++
    }
    println("sum = $sum, n = $n")  // sum = 105, n = 15
    
    // do-while: 先执行后判断
    var count = 0
    do {
        count++
    } while (count < 3)
    println("count = $count")  // 3
}

---

第四章 空安全

4.1 可空类型与安全调用

题目： 定义可空字符串 name，使用安全调用 ?. 获取其长度。

答案：

fun main() {
    val name: String? = "Kotlin"
    val len = name?.length
    println("Length: $len")  // 6
    
    val nullName: String? = null
    println("Null length: ${nullName?.length}")  // null
    
    // 链式调用
    val upper = name?.toUpperCase()
    println(upper)  // KOTLIN
}

---

4.2 Elvis 操作符

题目： 定义可空变量 str，当其为 null 时使用默认值 "default"。

答案：

fun main() {
    val str: String? = null
    val result = str ?: "default"
    println(result)  // default
    
    // 常用场景：函数参数默认值
    fun greet(name: String?) {
        val displayName = name ?: "Guest"
        println("Hello, $displayName!")
    }
    
    greet(null)      // Hello, Guest!
    greet("Alice")   // Hello, Alice!
}

---

4.3 非空断言与 let

题目： 安全处理可空字符串，将其转换为大写并打印长度，使用 ?.let 语法。

答案：

fun main() {
    val name: String? = "kotlin"
    
    // 使用 ?.let 安全处理
    name?.let {
        println("Uppercase: ${it.uppercase()}")
        println("Length: ${it.length}")
    }
    
    // 非空断言（慎用）
    val forced: String = name!!
    println(forced.uppercase())  // KOTLIN
    
    // null 时不执行
    val nullName: String? = null
    nullName?.let {
        println("This won't print")
    }
    println("After null check")
}

---

4.4 安全转型

题目： 使用 as? 安全地将 Any 类型转型为 String，失败时返回 null。

答案：

fun main() {
    val obj1: Any = "Hello"
    val obj2: Any = 123
    val obj3: Any = listOf(1, 2)
    
    val str1 = obj1 as? String
    val str2 = obj2 as? String
    val str3 = obj3 as? String
    
    println("obj1 as String: $str1")  // Hello
    println("obj2 as String: $str2")  // null
    println("obj3 as String: $str3")  // null
    
    // 配合 ?: 使用
    val result = obj2 as? String ?: "Not a String"
    println(result)  // Not a String
}

---

第五章 字符串

5.1 字符串模板

题目： 使用字符串模板打印以下内容：

Name: Kotlin, Version: 1.9
2 + 2 = 4
Path: C:\Users\Docs

答案：

fun main() {
    val name = "Kotlin"
    val version = "1.9"
    
    println("Name: $name, Version: $version")
    
    // 表达式用 ${}
    val a = 2
    println("$a + $a = ${a + a}")
    
    // 转义 $
    val price = 100
    println("Price: \$${price}")  // Price: $100
    
    // 原始字符串
    val path = """C:\Users\Docs"""
    println(path)
}

---

5.2 字符串操作

题目： 实现字符串处理函数：

1. 检查是否以 "K" 开头
2. 移除首尾空格
3. 替换 "old" 为 "new"
4. 分割字符串

答案：

fun main() {
    val str = "  Kotlin is awesome!  "
    
    println(str.trim())                  // Kotlin is awesome!
    println(str.trimStart())             // Kotlin is awesome!  (保留尾部空格)
    
    println(str.startsWith("K"))         // false (有前导空格)
    println(str.trim().startsWith("K"))  // true
    
    println(str.replace("awesome", "cool"))  //   Kotlin is cool!  
    
    val csv = "apple,banana,cherry"
    val parts = csv.split(",")
    println(parts)  // [apple, banana, cherry]
    
    // joinToString
    println(parts.joinToString(" | "))  // apple | banana | cherry
}

---

第六章 范围（Range）

6.1 数值范围

题目： 使用 Range 语法判断：

1. x 是否在 1-100 之间（闭区间）
2. y 是否不在 0-50 之间
3. 遍历 0-10 步长 2

答案：

fun main() {
    val x = 55
    val y = 80
    
    println(x in 1..100)   // true (闭区间，包含两端)
    println(y !in 0..50)   // true
    
    // 反向区间
    println(5 in 10..1)    // false
    
    // 遍历步长
    for (i in 0..10 step 2) {
        print("$i ")  // 0 2 4 6 8 10
    }
    println()
    
    // until: 不包含结束
    for (i in 0 until 10) {
        print("$i ")  // 0 1 2 3 4 5 6 7 8 9
    }
}

---

6.2 字符与日期范围

题目： 判断字符是否在 'A' 到 'Z' 之间；判断 2024 年是否是闰年。

答案：

fun main() {
    // 字符范围
    val c = 'M'
    println(c in 'A'..'Z')   // true
    println(c !in 'a'..'z')  // true
    
    // 日期范围
    val year = 2024
    val isLeapYear = year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)
    println("$year is leap year: $isLeapYear")  // true
    
    // 遍历字母
    for (char in 'A'..'F') {
        print("$char ")  // A B C D E F
    }
}

---

第七章 集合基础

7.1 listOf 创建列表

题目： 创建只读列表并实现：

1. 获取第一个和最后一个元素
2. 获取子列表（索引 1-3）
3. 检查元素是否存在

答案：

fun main() {
    val list = listOf("apple", "banana", "cherry", "date")
    
    println(list.first())    // apple
    println(list.last())     // date
    println(list[1])        // banana
    
    println(list.subList(1, 3))  // [banana, cherry]
    
    println("banana" in list)   // true
    println("grape" in list)    // false
    
    // 可变列表
    val mutable = mutableListOf(1, 2, 3)
    mutable.add(4)
    mutable.remove(2)
    println(mutable)  // [1, 3, 4]
}

---

7.2 setOf 创建集合

题目： 创建集合并观察去重特性；实现集合运算（交集、并集、差集）。

答案：

fun main() {
    val set = setOf(1, 2, 3, 2, 1, 4)
    println(set)  // [1, 2, 3, 4] (自动去重)
    
    val a = setOf(1, 2, 3, 4)
    val b = setOf(3, 4, 5, 6)
    
    println(a.union(b))        // [1, 2, 3, 4, 5, 6]
    println(a intersect b)     // [3, 4]
    println(a subtract b)      // [1, 2]
    
    // mutableSet
    val mutableSet = mutableSetOf<Int>()
    mutableSet.add(1)
    mutableSet.add(2)
    mutableSet.add(1)  // 重复，不添加
    println(mutableSet)  // [1, 2]
}

---

7.3 mapOf 创建映射

题目： 创建地图存储用户信息，实现：

1. 增删改查
2. 遍历所有键值对
3. 计算所有值的总和

答案：

fun main() {
    val map = mapOf("a" to 1, "b" to 2, "c" to 3)
    
    // 查询
    println(map["a"])           // 1
    println(map.getOrDefault("d", -1))  // -1
    
    // 遍历
    for ((key, value) in map) {
        println("$key -> $value")
    }
    
    // 可变 Map
    val mutableMap = mutableMapOf<String, Int>()
    mutableMap["x"] = 10
    mutableMap["y"] = 20
    mutableMap["x"] = 15  // 更新
    mutableMap.remove("y")
    println(mutableMap)  // {x=15}
    
    // 计算所有值的和
    println(map.values.sum())  // 6
}

---

第八章 函数式操作

8.1 forEach 与 map

题目： 对 [1, 2, 3, 4, 5] 实现：

1. 打印每个元素
2. 生成新列表：每个元素平方
3. 过滤出偶数

答案：

fun main() {
    val list = listOf(1, 2, 3, 4, 5)
    
    // forEach
    list.forEach { println(it) }
    
    // map: 转换每个元素
    val squared = list.map { it * it }
    println(squared)  // [1, 4, 9, 16, 25]
    
    // filter: 过滤条件
    val evens = list.filter { it % 2 == 0 }
    println(evens)  // [2, 4]
    
    // 链式调用
    list.map { it * 2 }
        .filter { it > 5 }
        .forEach { println(it) }  // 6, 8, 10
}

---

8.2 any, all, none

题目： 判断列表 [2, 4, 6, 8] 是否：

1. 全部是偶数
2. 至少有一个大于 5
3. 没有任何负数

答案：

fun main() {
    val list = listOf(2, 4, 6, 8)
    
    println(list.all { it % 2 == 0 })   // true (全部偶数)
    println(list.any { it > 5 })        // true (6, 8 满足)
    println(list.none { it < 0 })       // true (无负数)
    
    // 空集合的情况
    val empty = emptyList<Int>()
    println(empty.all { true })  // true (vacuous truth)
    println(empty.any { true })  // false
    println(empty.none { true }) // true
}

---

8.3 first, last, find

题目： 从 [1, 3, 5, 7, 9] 中：

1. 找到第一个大于 4 的元素
2. 找到最后一个小于 8 的元素
3. 找到第一个负数（不存在时返回 -1）

答案：

fun main() {
    val list = listOf(1, 3, 5, 7, 9)
    
    println(list.first { it > 4 })    // 5
    println(list.last { it < 8 })     // 7
    
    // find: 返回 null 而非抛异常
    println(list.find { it < 0 } ?: -1)  // -1
    println(list.find { it > 4 })       // 5
    
    // firstOrNull / lastOrNull
    println(list.firstOrNull { it > 100 })  // null
}

---

8.4 sum, average, count

题目： 计算 [10, 20, 30, 40] 的总和、平均值和元素个数。

答案：

fun main() {
    val list = listOf(10, 20, 30, 40)
    
    println(list.sum())     // 100
    println(list.average()) // 25.0
    println(list.count())   // 4
    
    // 带条件的统计
    println(list.count { it > 20 })  // 2 (30, 40)
    
    // reduce 和 fold
    println(list.reduce { acc, i -> acc + i })  // 100
    println(list.fold(100) { acc, i -> acc + i })  // 200 (初始值100)
}

---

答案汇总索引

章节	题目	核心知识点
1.1	val vs var	不可变 vs 可变
1.2	类型推导	类型推断与显式声明
1.3	const val	编译期常量
2.1-2.4	函数定义	默认参数、可变参数、Unit
3.1-3.5	控制流	if/when/for/while 表达式
4.1-4.4	空安全	?. / ?: / !! / as?
5.1-5.2	字符串	模板、常见操作
6.1-6.2	Range	闭区间、until、step
7.1-7.3	集合	List/Set/Map 基础
8.1-8.4	函数式	map/filter/forEach/any/all

---

基础篇结束。准备好进入 进阶篇 了吗？