Kotlin与Java对照手册

2025年4月24日 22:21

1. 基本类型

类型	Kotlin 写法	Java 写法	简要说明
数字	`Int`, `Long`, `Float`, `Double`, `Short`, `Byte`	`int`, `long`, `float`, `double`, `short`, `byte`	Kotlin 数值类型映射到相应的原生/包装类型。
布尔	`Boolean`	`boolean`	只能取 `true`/`false`，与数字不互通。
字符	`Char`	`char`	单个 Unicode 字符，支持转义序列。
字符串	`String`	`String`	不可变；支持多行文本块 `"""..."""`。
数组	`Array<T>`, `IntArray` 等	`T[]`	提供原始类型专用数组如 `IntArray`、`ByteArray`。
无符号整型	`UInt`, `ULong`, `UShort`, `UByte`	无	编译时检查范围，运行时越界抛 `IllegalArgumentException`。

2. 语法对照

功能	Java 写法	Kotlin 写法	简要说明
变量定义	`int x = 10;` `final String name = "Tom";`	`var x = 10` `val name = "Tom"`	`var` 可变，`val` 只读；类型由编译器推断。
类 + 构造	`public class P { P(String n) { ... } }`	`class P(val name: String)`	主构造中声明属性，自动生成字段 & 访问器。
数据类	手动写字段/构造/`equals`/`toString`	`data class User(val id: Int, val n: String)`	`data` 自动生成常用方法 & 解构组件。
函数定义	`public int sum(int a, int b) { return a + b; }`	`fun sum(a: Int, b: Int) = a + b`	表达式函数可省略大括号和 `return`。
空安全	`if (s != null) len = s.length(); else len = 0;`	`val len = s?.length ?: 0`	`String?` 可空，`?.` 与 `?:` 插入编译期空检查。
分支匹配	`switch(x) { case 1: ... }`	`when(x) { 1 -> ...; else -> ... }`	`when` 是表达式，支持范围 & 任意对象比较。
循环 & 集合	for(int i=0;i<10;i++)``list.stream().filter()	for(i in 0 until 10)``list.filter{}	`0 until` 生成 `IntRange`；集合链式调用基于扩展函数。
单例	`class S { private static S i=new S(); … }`	`object S { fun foo() {} }`	`object` 编译时生成线程安全单例，无需额外样板。

3. 独有亮点

特性	示例	简要说明
默认 & 命名参数	`fun g(msg: String = "Hi", name: String = "You")` `g(name="Tom")`	编译器生成默认方法，命名参数避免重载歧义。
扩展函数	`fun String.ex() = uppercase()`	编译后为静态方法，第一个参数是接收者，调用如成员方法。
解构声明	`val (x, y) = Point(1, 2)`	`data class` 自动生成 `componentN()`，一行取多值。
密封类	`sealed class R; data class Ok(val d: String): R(); object Err: R()`	限定子类范围，`when` 可做穷尽检查。
内联函数	`inline fun <T> m(b: ()->T): T { … }`	在调用处展开函数体，减少高阶函数的运行时开销。
集合构造器	`listOf(1, 2)`, `mutableListOf("A")`, `mapOf("a" to 1)`	内建集合工厂函数，语法简洁；`to` 表示键值对。
数组构造器	`arrayOf(1, 2)`, `intArrayOf(1, 2)`	支持泛型与原始类型数组，避免装箱。
表达式返回值	`val max = if (a > b) a else b` `val result = try { … } catch { … }`	`if`、`when`、`try` 都是表达式，可直接赋值。
区间语法 & 步进	`for (i in 1..5)`, `for (j in 1 until 5 step 2)`	`..` 表闭区间，`until` 表半开，`step` 控制步长。
字符串模板	`"Hello, $name"` `"Length: ${s.length}"`	`$变量` 可直接拼接，复杂表达式用 `${}`。
Lambda 尾随语法	`list.filter { it > 0 }.map { it * 2 }`	大括号可直接跟随函数调用，链式语法自然、简洁。

4. 常用标准库函数

函数	用法示例	简要说明
`let`	`user?.let { print(it.name) }`	非空时执行块，`it` 引用原对象。
`apply`	`User().apply { age = 18 }`	在对象上执行块并返回该对象，常用于初始化。
`also`	`list.also { println("init") }`	执行副作用并返回对象，常用于日志 / 调试。
`run`	`val r = run { compute(); result }`	无接收者的作用域块，返回最后一行结果。
`with`	`with(cfg) { load(); validate() }`	对象上下文块，`this` 指向接收者，返回结果。
`takeIf`	`str.takeIf { it.isNotBlank() }`	条件为真返回对象，否则返回 `null`。
`sequence`	`sequenceOf(1,2,3).map { … }`	惰性集合处理，适合大规模数据管道。

5. 类型系统对比

功能	Java 写法	Kotlin 写法	简要说明
泛型	`List<String>`	`List<String>`	支持协变 / 逆变（`out` / `in`）和 `reified` 泛型函数。
类型别名	无	`typealias Name = String`	简化复杂类型声明。
枚举类	`enum Color { RED, GREEN }`	`enum class Color { RED, GREEN }`	支持在枚举中定义属性 & 方法。
内联类	无	`@JvmInline value class USD(val amount: Int)`	编译时包装或展开，零开销封装。

6. 类型检测与转换

功能	Java 写法	Kotlin 写法	简要说明
类型检查	`if (obj instanceof String)`	`if (obj is String)`	`is` 后自动智能转换，无需显式强转。
安全转换	`(String) obj`	`obj as String` / `obj as? String`	`as?` 安全转换失败返回 `null`。
基本转换	`Integer.parseInt(str)`	`str.toInt()`, `toDouble()`, `toLong()`	通过扩展函数提供常见类型转换。

7. 控制流程 & 异常

功能	Java 写法	Kotlin 写法	简要说明
条件 & 循环	`if`, `switch`, `for`, `while`, `do-while`	`if`, `when`, `for`, `while`, `do-while`	`when` 可做表达式，替代 `switch`。
返回 & 跳转	`return`, `break`, `continue`, `throw`	同 Java	支持在 lambda 中局部返回，如 `return@label`。
异常处理	`try-catch-finally`, checked exception	`try-catch-finally`，无 checked exception	Kotlin 不区分受检异常，简化错误处理。

8. 包与导入

功能	Java 写法	Kotlin 写法	简要说明
包声明	`package com.example;`	`package com.example`	不需要分号。
导入	`import java.util.List;`	`import java.util.List`	支持导入顶层函数和属性。
别名导入	无	`import foo.Bar as Baz`	解决命名冲突或简化引用。

9. 面向对象相关

功能	Java 写法	Kotlin 写法	简要说明
接口默认实现	`default void f() {}`	接口中可直接写方法体	接口内方法可有实现，无需关键字。
抽象类	`abstract class Shape { … }`	`abstract class Shape { … }`	抽象成员不需再加 `abstract` 前缀。
继承 & 覆写	`class A extends B { @Override … }`	`class A : B() { override fun … }`	用 `:` 表示继承，`override` 必显式标注。
可见性修饰符	`public`/`protected`/`private`	`public`/`protected`/`private`/`internal`	`internal` 表示同模块内可见。
内部类	`class Outer { class Inner {} }`	`class Outer { inner class Inner {} }`	默认是静态嵌套，加 `inner` 变为非静态内部类。

10. 协程 vs 多线程

场景	Java 写法（线程/异步）	Kotlin 写法（协程）	简要说明
启动任务	`new Thread(() -> work()).start();`	`GlobalScope.launch { work() }`	协程更轻量、省资源，适合大规模并发。
异步返回值	`Future<Integer> f = exec.submit(...);`	`val result = async { compute() }.await()`	内建 `async/await`，语义更清晰。
延迟执行	`Thread.sleep(1000)`	`delay(1000)`	非阻塞挂起，不占用线程。
结构化并发	手动管理线程池和生命周期	`coroutineScope { … }`	协程作用域自动管理生命周期，避免泄漏。

📦 11. 集合操作对比

功能	Java 写法（Stream）	Kotlin 写法（扩展函数）	简要说明
过滤	`list.stream().filter(x -> x > 0).collect(...)`	`list.filter { it > 0 }`	语法简洁，链式调用更直观。
映射	`list.stream().map(x -> x * 2).collect(...)`	`list.map { it * 2 }`	Lambda 简洁，扩展函数无额外依赖。
分组	`Collectors.groupingBy(...)`	`list.groupBy { it.key }`	直接返回 `Map<K, List<V>>`，更易读。
排序	`list.sort(Comparator.comparing(...))`	`list.sortedBy { it.prop }`	函数式排序，链式可读性好。
聚合	`reduce`, `sum`, `collect`	`reduce`, `sumOf`, `fold`	内建多种聚合函数，常用时无需额外导入。

参考：

Kotlin内核编程
 Kotlin 语言参考文档
 深入理解Kotlin协程
 有没有 Kotlin 讲协程比较好的书籍或博客连载
 Kotlin 官方文档中文版

LeetCode: Make a Square with the Same Color

YeungYeah 的乱写地

yeungyeah@qq.com (YeungYeah)

2024年8月31日 11:25

Problem

source: 3127. Make a Square with the Same Color

difficulty: easy

You are given a 2D matrix grid of size 3 x 3 consisting only of characters 'B' and 'W'. Character 'W' represents the white color, and character 'B' represents the black color.

Your task is to change the color of at most one cell so that the matrix has a 2 x 2 square where all cells are of the same color.

Return true if it is possible to create a 2 x 2 square of the same color, otherwise, return false.

Constraints:

grid.length == 3
``grid[i].length == 3`
grid[i][j] is either 'W' or 'B'.

Solution

问题可以转化成判断 matrix 是否存在一个 2 * 2 的 matrix，其中包含 3 or 4 个相同的元素。

但是再仔细一看 matrix 只有 3 * 3，因此可以直接分成 4 个 block，分别判断 4 个 block 是否存在就行了。

Kotlin

直接判断每一个点分别在哪些 block 里面，但是这几个 if 判断就写得很丑陋（写了一个之后干脆打开 GitHub Copilot 生成算了）

class Solution {
 fun canMakeSquare(grid: Array<CharArray>): Boolean {
 val cnt = IntArray(4)
 fun Char.value(): Int = if (this == 'B') 1 else -1

 for (i in 0..2) {
 for (j in 0..2) {
 if ( i < 2 && j < 2) cnt[0] += grid[i][j].value()
 if ( i < 2 && j > 0) cnt[1] += grid[i][j].value()
 if ( i > 0 && j < 2) cnt[2] += grid[i][j].value()
 if ( i > 0 && j > 0) cnt[3] += grid[i][j].value()
 }
 }

 return cnt.any() { it in listOf(2, -2, 4, -4) }
 }
}

Scala

最近在学 Scala，于是自然又用 Scala 写一次。相比于此前丑陋的 if 判断，干脆写得更加函数式，试一下 loop free。

直接三行搞定。

object Solution {
 def canMakeSquare(grid: Array[Array[Char]]): Boolean = {
 def getRange = for { i <- 0 to 1; j <- 0 to 1} yield (i, j)

 def check(x: Int, y: Int): Boolean = getRange.count((i, j) => grid(x + i)(y + j) == 'B') != 2

 getRange.count((i, j) => check(i, j)) >= 1
 }
}

阅读视图

OpenClaw Workspace 完全指南——打造你的专属 AI 编程助手