Kotlin 学习
- User
Kotlin 学习
- Assistant
🎯 Kotlin 学习路线 & 资源指南
先问一句:
👉 你目前的背景是 Java/Python/C++?主要想用 Kotlin 做 Android、后端(Ktor/Spring)、还是跨平台(KMP)?—— 回答后我可以按需细化 😊
一、为什么学 Kotlin?
- 官方支持:Android 官方首选语言,Google I/O 多年力推。
- 语法简洁:null 安全、扩展函数、协程非常香。
- 100% 兼容 Java:能够渐进式迁移旧项目。
- 跨平台:Kotlin Multiplatform 可共享业务逻辑到 iOS/JS/桌面/服务器。
二、学习前置
建议掌握 说明 基础编程思维 变量、流程控制、函数、OOP Java 基础(可选) 有助理解 JVM 与生态,但不是硬性要求 IDE 使用 IntelliJ IDEA / Android Studio
三、环境搭建
- 安装 JDK 8+(OpenJDK/AdoptOpenJDK 都可)。
- 安装 IntelliJ IDEA 或 Android Studio(自带 Kotlin 插件)。
- Hello Kotlin:
fun main() { println("Hello, Kotlin!") }IDE 直接
Run即可。命令行也行:kotlinc hello.kt -include-runtime -d hello.jar java -jar hello.jar
四、学习路线图
1. 语言基础
- 变量 & 常量:
valvsvar - 数据类型 & 字面量:字符串模板、集合
- 函数:默认参数、命名参数、单表达式函数
- 控制流:
if、when、for、while - 空安全:
?、!!、 Elvis 运算符?: - 面向对象:类、接口、数据类、密封类
- 高阶函数 & Lambda、集合操作(map/filter/reduce)
- 扩展函数、扩展属性
- 标准库:
let,run,apply,with,also
2. 进阶特性
- 泛型 & 协变 / 逆变
- 委托 & 委托属性
- Inline / Reified
- 协程(Coroutines):挂起函数、作用域、流 Flow
- DSL 构建(渐进了解 Gradle DSL、Anko、Jetpack Compose)
3. 生态与实战
根据方向选择模块:
方向 推荐模块 Android Jetpack Compose、Lifecycle、Room、Hilt、协程、Flow 服务器 Ktor、Spring Boot + Kotlin、Exposed ORM 跨平台 Kotlin Multiplatform Mobile (KMM) + SwiftUI/React 桌面 Compose Multiplatform、TornadoFX 数据科学 Kotlin Notebook、KotlinDL
五、经典资源
📚 图书
- 《Kotlin 编程权威指南(第2版)》
- 《Kotlin 协程设计》
- Effective Kotlin(英文,但作者在 JetBrains)
🌐 官方文档
- https://kotlinlang.org/docs/home.html
- Kotlin Playground 在线试码:https://play.kotlinlang.org
📝 交互教程
- Kotlin Koans(IDE 插件 or 网页版):通过测试驱动学习
- Kotlin Bootcamp for Programmers(Google Codelabs)
🎥 视频 / 课程
- JetBrains Academy Kotlin 路线(交互式)
- Coursera《Kotlin for Java Developers》
- B 站:Kotlin 入门到进阶系列(按点赞排序挑质量高的 UP)
👥 社区
- Kotlin 中文社区微信/QQ群
- Stack Overflow 标签
kotlin - r/Kotlin (Reddit)
六、实战练习建议
难度 练习思路 ⭐ 刚上手 ① 写一个命令行 Todo 应用;② LeetCode 用 Kotlin 刷 10 题 ⭐⭐ 熟练 ③ 用 Ktor 写 RESTful API + SQLite;④ 写 Android Compose 记账 App ⭐⭐⭐ 高阶 ⑤ 用协程 + Flow 实现聊天 IM;⑥ 拔草 KMM 做共享业务逻辑 Demo Tips:保持“最小可用”原则,小步迭代,写博客总结踩坑。
七、易踩的坑
- Null 安全滥用
!!:能不用就不用。 - 协程作用域混乱:牢记
viewModelScope / lifecycleScope / GlobalScope差异。 - Java ↔ Kotlin 互调:
@JvmOverloads、SAM 转换、Checked Exception 细节。 - Extension 函数不是万能:过度使用会让代码可读性下降。
- Kapt & Annotation Processor 性能:能用 Kotlin Symbol Processing(KSP)更佳。
八、下一步怎么做?
- 先走一遍 Kotlin Koans,完成后对语法会有整体感知。
- 选定方向(Android/后端/KMP)→ 选项目 → 在做中学。
- 每周写 1~2 篇学习笔记/博客,强化输出。
- 遇到具体问题及时提问(Issue、论坛、社区群)。
👇 想更个性化?告诉我:
- 你的编程基础(比如:2 年 Java、0 基础…)
- 主要目标(Android? 服务端? 跨平台?)
- 学习时间安排(每周几小时?)
我可以帮你再拆解成「30 天打卡计划」或「项目驱动学习清单」。加油!🚀
- User
会计科目表批量插入程序设计,需要依赖父级正确一直到一级科目
- Assistant
会计科目表批量导入方案(Kotlin 示例)
目标
- ⾃动校验:每条科目记录的“父级”必须存在(数据库已有或本次导入文件中)。
- ⾃动排序:保证插入顺序由 一级 → … → 末级,避免外键/约束失败。
- 原子性:整批写⼊要么全部成功,要么全部回滚。
下面给出一套“通用思路 + Kotlin/Exposed 代码雏形”。如果你用其它语言或 ORM,把核心算法部分迁过去即可。
1. 数据模型示例
假设数据库表
account_subjects:字段 类型 说明 id BIGINT 主键(雪花或序列) code VARCHAR(20) 科目编码(唯一) name VARCHAR(100) 科目名称 level INT 级次(1=一级) parent_code VARCHAR(20) 父级科目编码(可空) created_at ... … 省略 并建唯一索引
code+ 外键parent_code → code。MySQL 外键不可 deferred,所以必须“父在前、子在后”;PostgreSQL 可以
DEFERRABLE INITIALLY DEFERRED,那就不强制排序了,但下面统一按需排序,数据库无关。
2. 导入文件格式
最常见:Excel/CSV。示例 CSV:
code,name,level,parent_code 1001,库存现金,1, 100101,人民币库存现金,2,1001 10010101,北京分公司现金,3,100101 2202,应付账款,1, ...
3. 总体流程
┌──────────┐ │ 读取文件 │ └────┬─────┘ │ ▼ ┌────────────────────────┐ │ ① 解析为 Kotlin 对象 │ └────┬───────────────────┘ │ ▼ ┌────────────────────────┐ │ ② 逐条校验父级链合法 │ │ - 父级在 DB 或文件 │ └────┬───────────────────┘ │ (失败 → 终止) ▼ ┌────────────────────────┐ │ ③ 拓扑排序(按 level) │ └────┬───────────────────┘ │ ▼ ┌────────────────────────┐ │ ④ DB事务批量插入 │ │ Exposed.batchInsert │ └────────────────────────┘
4. 关键实现
4.1 Kotlin 数据类
data class AccountCsvRow( val code: String, val name: String, val level: Int, val parentCode: String? )4.2 读取并解析 CSV(以 kotlin-csv 为例)
val rows: List<AccountCsvRow> = File("subjects.csv").readCsv() .drop(1) // 跳过表头 .map { columns -> AccountCsvRow( code = columns[0].trim(), name = columns[1].trim(), level = columns[2].trim().toInt(), parentCode = columns[3].trim().ifBlank { null } ) }4.3 构建索引,校验父级链
// 方便 O(1) 查询 val fileCodeMap = rows.associateBy { it.code } // 先查一次数据库已有科目 val dbCodeSet: Set<String> = Accounts .slice(Accounts.code) .selectAll() .map { it[Accounts.code] } .toSet() // 检查每条记录的父级链 fun checkParentChain(row: AccountCsvRow) { var currentParent = row.parentCode var depth = 0 while (currentParent != null) { depth++ if (depth > 10) error("层级循环或过深:${row.code}") if (currentParent !in dbCodeSet && currentParent !in fileCodeMap) { error("科目 ${row.code} 的父级 $currentParent 不存在") } currentParent = fileCodeMap[currentParent]?.parentCode } } rows.forEach(::checkParentChain)4.4 拓扑排序(简单按 level / BFS)
因为每行都带
level,可直接:val orderedRows = rows.sortedWith(compareBy<AccountCsvRow> { it.level }.thenBy { it.code })若没有 level 字段,可做 拓扑排序:
fun topoSort(nodes: Collection<AccountCsvRow>): List<AccountCsvRow> { val inDegree = mutableMapOf<String, Int>() nodes.forEach { inDegree[it.code] = 0 } nodes.forEach { r -> r.parentCode?.let { inDegree[r.code] = inDegree[r.code]!! + 1 } } val queue: ArrayDeque<AccountCsvRow> = ArrayDeque(nodes.filter { inDegree[it.code] == 0 }) val result = mutableListOf<AccountCsvRow>() while (queue.isNotEmpty()) { val n = queue.removeFirst() result += n nodes.filter { it.parentCode == n.code }.forEach { child -> inDegree[child.code] = inDegree[child.code]!! - 1 if (inDegree[child.code] == 0) queue += child } } if (result.size != nodes.size) error("检测到循环依赖!") return result }4.5 批量插入(Exposed DSL)
object Accounts : Table("account_subjects") { val id = long("id").autoIncrement() val code = varchar("code", 20).uniqueIndex() val name = varchar("name", 100) val level = integer("level") val parentCode = varchar("parent_code", 20).nullable().index() override val primaryKey = PrimaryKey(id) } transaction { addLogger(StdOutSqlLogger) Accounts.batchInsert(orderedRows) { row -> this[Accounts.code] = row.code this[Accounts.name] = row.name this[Accounts.level] = row.level this[Accounts.parentCode] = row.parentCode } }一旦事务提交失败(比如唯一索引冲突、外键失败),Exposed 会抛异常,整个批次回滚;业务侧捕获后提示用户。
5. 边界 & 优化
-
唯一冲突
- 导入前可让用户选择:忽略重复 / 覆盖 / 提示并终止。
- 覆盖可用
ON DUPLICATE KEY UPDATE(MySQL)或ON CONFLICT (code) DO UPDATE(PG)。
-
外键策略
- MySQL:保持「父先子后」即可。
- PG:可把外键设为
DEFERRABLE INITIALLY DEFERRED,那就不必排序;批量插完再自动检查。
-
文件过大
- 10 万+ 行时可分批 5 000 行 commit,或者用 COPY(PG)/ LOAD DATA(MySQL)到临时表,再执行一次
UPDATE … SET parent_id = parent.id。
- 10 万+ 行时可分批 5 000 行 commit,或者用 COPY(PG)/ LOAD DATA(MySQL)到临时表,再执行一次
-
UI 友好
- 上传后先跑“预检”,生成报告:
- 缺失父级
- 重复 code
- 层级异常
- 全部通过再执行真正写入,提高体验。
- 上传后先跑“预检”,生成报告:
6. 完整伪代码 (汇总)
fun importSubjects(csvPath: String) { val rows = parseCsv(csvPath) val dbCodes = queryExistingCodes() rows.forEach { checkParentChain(it, rows, dbCodes) } val ordered = rows.sortedBy { it.level } // or topoSort(rows) transaction { Accounts.batchInsert(ordered) { r -> this[Accounts.code] = r.code this[Accounts.name] = r.name this[Accounts.level] = r.level this[Accounts.parentCode] = r.parentCode } } }
7. 小结
- “先校验 → 再排序 → 一次事务插入” 是最简单稳妥的套路。
- 不想自己手排序,可选 PostgreSQL +
DEFERRABLE外键,一口气插完;但跨库兼容就还是排下序。 - Kotlin + Exposed/Vertx/Coroutine 对 I/O 友好,写大量批处理很舒适。
如果你有:
- 具体库(MyBatis / Jooq)
- 较大数据量 & 性能疑问
- 多租户/多套会计制度差异化
欢迎再告诉我,给你“定制版”方案 😉
- User
level 可能不准,根据 code 排序呢,根据科目枚举,分成了几组,或者几颗树,每棵树先处理上级科目
- Assistant
🎯 需求再澄清
level字段不靠谱,甚至没有。code本身体现层级(典型:父 code 是子 code 的前缀),但一张表里可能有多颗“会计科目树”。- 同时还有「科目枚举」字段(如 ASSETS / LIABILITY …)对科目进行分组,要求“先按枚举分树,再保证每棵树父在前、子在后”插入。
下面给出纯 code-driven 拓扑排序方案,无需依赖
level。
Kotlin + Exposed 演示,换成 MyBatis/SQL 也只需把最终orderedRows批量插库即可。
一、核心思路
- 解析上传文件 →
List<Row> - ⾃动推导父 code
• 如果文件里显式有parent_code列,直接用
• 否则用“最长前缀法”推导:- 在同一枚举组里找比自己短且是自己前缀、长度最近的 code 作为父
- 按
enumGroup(资产/负债…)拆成多颗树 - 对每颗树做 DFS / 拓扑排序,得到“父→子”顺序
- 事务批量插入
二、数据类
data class SubjectRow( val enumGroup: String, // 资产、负债… val code: String, // 1001 / 220201 … val name: String, val parentCode: String? // 可能为空,后⾯自动推导 )
三、推导父级 & 构树
/** * 找到同组内比自己短、且是自己前缀的 code 中“最长”的那个 */ fun inferParent(row: SubjectRow, candidates: Set<String>): String? = generateSequence(row.code.length - 1) { it - 1 } // 从 len-1 递减 .map { row.code.substring(0, it) } // 逐步截掉尾字符 .firstOrNull { it in candidates } // 第一个命中的就是最近父级 fun buildParentMap(rows: List<SubjectRow>): Map<String, String?> { val groupMap = rows.groupBy { it.enumGroup } val parentMap = mutableMapOf<String, String?>() groupMap.values.forEach { sameGroupRows -> val codes = sameGroupRows.map { it.code }.toSet() sameGroupRows.forEach { r -> val parent = r.parentCode ?: inferParent(r, codes) parentMap[r.code] = parent } } return parentMap }
四、DFS 拓扑排序(按组)
fun topoSortByEnum(rows: List<SubjectRow>): List<SubjectRow> { val byEnum = rows.groupBy { it.enumGroup } val codeRowMap = rows.associateBy { it.code } val parentMap = buildParentMap(rows) val sorted = mutableListOf<SubjectRow>() val seen = mutableSetOf<String>() val visiting = mutableSetOf<String>() // 用来检测循环 fun dfs(code: String) { if (code in seen) return if (!visiting.add(code)) error("检测到循环引用:$code") parentMap[code]?.let { dfs(it) } // 先递归父节点 visiting.remove(code) seen += code sorted += codeRowMap.getValue(code) } byEnum.values.forEach { groupRows -> groupRows.forEach { dfs(it.code) } } return sorted }⼀旦发现循环(
dfs中重复入栈),立即抛错终止导入。
五、完整导入流程
fun importSubjects(rows: List<SubjectRow>) { // ① 父链校验 + 排序 val orderedRows = topoSortByEnum(rows) // ② 可选:额外校验父 code 已存在于 DB 或 orderedRows 前段 // …(略) // ③ 事务批量插入 transaction { Accounts.batchInsert(orderedRows) { r -> this[Accounts.code] = r.code this[Accounts.name] = r.name this[Accounts.enumGroup] = r.enumGroup this[Accounts.parentCode] = buildParentMap(rows)[r.code] } } }
六、常见变体 & Tips
-
不是前缀关系怎么办?
- 仍保留
parent_code列即可;算法先用显式列,缺失时才推导。
- 仍保留
-
科目号长度不定,比如
1001/10010102/1121.01?- 推导父级时仍走最长“合法前缀”策略,只需把分隔符统一剥离或同时比对。
-
超大文件(10 万行):
- 不想 DFS 全塞内存?可先写入 临时表,然后单条
UPDATE subject SET parent_id = p.id …批量搞定。 - 或「分块 5k 行」两级循环 DFS → batchInsert。
- 不想 DFS 全塞内存?可先写入 临时表,然后单条
-
数据库层「不想自己排顺序」:
- PostgreSQL 外键
DEFERRABLE INITIALLY DEFERRED,插完一次性校验。 - 但跨库兼容 or MySQL 就老老实实按上面顺序插。
- PostgreSQL 外键
七、一图速览
┌──────────┐ │ 读取文件 │ └────┬─────┘ ▼ ┌─────────────────┐ │ 构建 parentMap │◄───────────────┐ └────┬────────────┘ │ ▼ │ ┌─────────────────────┐ │ │ DFS/拓扑(按enum组) │ │ └────┬────────────────┘ │ ▼ │ ┌─────────────────────┐ │ │ orderedRows (父→子) │ │ └────┬────────────────┘ │ ▼ │ ┌─────────────────────┐ │ │ 事务 batchInsert │ │ └─────────────────────┘ │ ▲ │ └──────── 校验异常/回滚 ───┘
✅ 这样就能:
• 不依赖level;
• 多枚举组多颗树也 OK;
• 保证父级在子级之前插入。如果还有特殊格式、性能瓶颈或想看 纯 SQL 版实现,随时告诉我!🚀
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.