Java ↔ Kotlin 速查对照表

---

变量与类型

// Java
String name = "Kotlin";
final int age = 25;
int count;  // 基本类型，默认值0

// Kotlin
val name = "Kotlin"        // 不可变，自动推断 String
var age = 25               // 可变 Int
val score: Double = 98.5    // 显式声明类型
const val MAX = 100         // 编译期常量

---

函数

// Java
public int add(int a, int b) {
    return a + b;
}

// Kotlin
fun add(a: Int, b: Int): Int = a + b

// 默认参数
fun greet(name: String, prefix: String = "Hello") = "$prefix, $name"

// 可变参数
fun sum(vararg numbers: Int) = numbers.sum()

---

字符串

// Java
String msg = "Hello, " + name + "!";
String s = "abc".substring(0, 2);
String[] arr = "a,b".split(",");

// Kotlin
val msg = "Hello, $name!"
val len = "Length: ${name.length}"
val s = "abc".substring(0, 2)
val arr = "a,b".split(",")
val joined = listOf("a","b").joinToString("-")

---

空安全

// Java
if (str != null && !str.isEmpty()) {
    System.out.println(str.length());
}
String result = (obj != null) ? obj.getName() : "default";

// Kotlin
str?.length                          // 安全调用，null 返回 null
str?.length ?: 0                     // Elvis 操作符
str!!.length                         // 非空断言，null 抛异常
val result = obj?.name ?: "default"  // 判空 + 默认值

---

条件控制

// Java
int max = (a > b) ? a : b;
switch (x) {
    case 1: System.out.println("one"); break;
    default: System.out.println("other");
}

// Kotlin
val max = if (a > b) a else b

when (x) {
    1 -> println("one")
    in 2..10 -> println("range")
    is String -> println("string")
    else -> println("other")
}

// when 作为表达式
val result = when (x) {
    1 -> "one"
    else -> "other"
}

---

循环

// Java
for (int i = 0; i < 5; i++) { }
for (String item : list) { }
for (Map.Entry<K, V> e : map.entrySet()) { }

// Kotlin
for (i in 0..4) { }
for (item in list) { }
for ((k, v) in map) { }
for (i in 0 until 5 step 2) { }  // 0,2,4

---

集合创建

// Java
List<String> list = new ArrayList<>();
list.add("a");
Map<String, Integer> map = new HashMap<>();
map.put("a", 1);

// Kotlin
val list = listOf("a", "b")
val mutable = mutableListOf("a", "b")
val map = mapOf("a" to 1, "b" to 2)
val mutableMap = mutableMapOf("a" to 1)

---

集合遍历

// Java
for (String item : list) {
    System.out.println(item);
}
for (Map.Entry<String, Integer> e : map.entrySet()) {
    System.out.println(e.getKey() + ":" + e.getValue());
}

// Kotlin
list.forEach { println(it) }
list.forEachIndexed { i, v -> println("$i: $v") }
for ((k, v) in map) println("$k: $v")

---

集合过滤/转换

// Java
List<Integer> evens = new ArrayList<>();
for (Integer n : numbers) {
    if (n % 2 == 0) evens.add(n);
}
List<String> upper = new ArrayList<>();
for (String s : list) upper.add(s.toUpperCase());

// Kotlin
val evens = numbers.filter { it % 2 == 0 }
val upper = list.map { it.uppercase() }
val pair = list.map { it to it.length }.toMap()

---

Lambda 表达式

// Java
list.sort((a, b) -> a.compareTo(b));
list.forEach(item -> System.out.println(item));

// Kotlin
list.sortWith(compareBy { it })
list.forEach { println(it) }
list.filter { it > 0 }.map { it * 2 }

---

类型转换

// Java
String s = (String) obj;
if (obj instanceof String) {
    String str = (String) obj;
}

// Kotlin
val s = obj as String
val str = obj as? String  // 安全转换，失败返回 null

---

异常处理

// Java
try {
    int r = 10 / 0;
} catch (ArithmeticException e) {
    e.printStackTrace();
} finally {
    System.out.println("done");
}

// Kotlin
try {
    val r = 10 / 0
} catch (e: ArithmeticException) {
    println(e.message)
} finally {
    println("done")
}

// throw 是表达式
val result = try {
    input.toInt()
} catch (e: NumberFormatException) {
    0
}

---

枚举

// Java
enum Color { RED, GREEN, BLUE }

// 使用
Color c = Color.RED;

// Kotlin
enum class Color { RED, GREEN, BLUE }
enum class Status(val code: Int) {
    SUCCESS(200),
    ERROR(500);
}

---

静态方法 / 单例

// Java 静态方法
public class Utils {
    public static int max(int a, int b) { return Math.max(a, b); }
}
// 调用: Utils.max(a, b)

// 单例
public class AppConfig {
    private static final AppConfig instance = new AppConfig();
    public static AppConfig getInstance() { return instance; }
}

// Kotlin — 顶层函数（推荐）
fun max(a: Int, b: Int) = if (a > b) a else b
// 调用: max(a, b)

// 单例
object AppConfig {
    val version = "1.0"
    fun init() { }
}
// 调用: AppConfig.version / AppConfig.init()

---

类的创建与继承

// Java
public class Animal {
    private String name;
    public Animal(String name) { this.name = name; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
}
public class Dog extends Animal {
    public Dog(String name) { super(name); }
}

// Kotlin
class Animal(val name: String)

open class Animal2(val name: String) {
    open fun sound() = "..."
}
class Dog(name: String) : Animal2(name) {
    override fun sound() = "汪"
}

// 数据类
data class User(val id: Int, val name: String)

---

接口实现

// Java
public interface ClickListener {
    void onClick(View v);
}
public class MyActivity implements ClickListener {
    @Override
    public void onClick(View v) { }
}

// Kotlin
interface ClickListener {
    fun onClick(view: View)
}
class MyActivity : ClickListener {
    override fun onClick(view: View) { }
}

---

延迟初始化

// Java
private UserService service;  // 初始 null，需自行判空

// Kotlin
lateinit var service: UserService   // 用前必须赋值，否则抛异常

val lazyService: UserService by lazy { UserService() }  // 首次访问时初始化

---

可变参数

// Java
public void printAll(String... args) {
    for (String arg : args) System.out.println(arg);
}

// Kotlin
fun printAll(vararg args: String) {
    args.forEach { println(it) }
}

---

内联类（类型安全）

// Java — 没有直接对应，通常用包装类
// UserId 和 OrderId 都是 Long，无法区分

// Kotlin
@JvmInline
value class UserId(val value: String)
@JvmInline
value class OrderId(val value: String)

fun findUser(id: UserId) { }
findUser(UserId("123"))  // 类型安全

---

伴生对象（静态成员）

// Java
public class MyClass {
    public static final String TAG = "MyClass";
    public static MyClass newInstance() { return new MyClass(); }
}

// Kotlin
class MyClass {
    companion object {
        const val TAG = "MyClass"       // 编译期常量
        fun newInstance() = MyClass()
    }
}
// 调用: MyClass.TAG / MyClass.newInstance()

---

建造者模式 / 链式调用

// Java
AlertDialog dialog = new AlertDialog.Builder(context)
    .setTitle("Title")
    .setMessage("Message")
    .setPositiveButton("OK", null)
    .create();

// Kotlin — 用 apply / also
val dialog = AlertDialog.Builder(context).apply {
    setTitle("Title")
    setMessage("Message")
    setPositiveButton("OK", null)
}.create()

val list = mutableListOf<Int>().also {
    it.add(1)
    it.add(2)
}

---

Getter/Setter 自定义

// Java
private int score;
public int getScore() { return score * 10; }
public void setScore(int value) { this.score = value; }

// Kotlin
var score: Int = 0
    get() = field * 10
    set(value) { field = value }

---

导航运算符（链式判空）

// Java
String name = (user != null && user.getProfile() != null)
    ? user.getProfile().getName() : null;

// Kotlin
val name = user?.profile?.name
val city = user?.address?.city ?: "未知"
val name2 = user!!.profile!!.name  // 强制非空，慎用

---

when 强大用法

// Java — 只能匹配常量/枚举/int
switch (status) {
    case 1: result = "成功"; break;
    case 2: result = "失败"; break;
    default: result = "未知";
}

// Kotlin — 匹配任意类型/范围/类型
val result = when (status) {
    1 -> "成功"
    2 -> "失败"
    in 3..10 -> "范围"
    is String -> "字符串: $status"
    null -> "空"
    else -> "未知"
}

// when 作为条件
val desc = when {
    x > 0 && y > 0 -> "第一象限"
    x < 0 && y > 0 -> "第二象限"
    else -> "其他"
}

---

区间判断

// Java — 没有区间概念，用 && 连接
if (x >= 0 && x <= 100) { }

// Kotlin
if (x in 0..100) { }
when (x) {
    in 1..10 -> "小"
    in 11..100 -> "中"
    !in 1..1000 -> "超出范围"
}

// 遍历区间
for (i in 0..100 step 5) { }       // 0,5,10...100
for (i in 100 downTo 0 step 10) { }

---

运算符重载

// Java — 不支持运算符重载

// Kotlin — 常用运算符对应方法
a + b     → a.plus(b)
a - b     → a.minus(b)
a * b     → a.times(b)
a / b     → a.div(b)
a % b     → a.mod(b)
a == b    → a?.equals(b) ?: (b === null)
a..b      → a.rangeTo(b)
a in list → list.contains(a)

// 自定义
class Point(var x: Int, var y: Int) {
    operator fun plus(other: Point) = Point(x + other.x, y + other.y)
}

---

协程基础

// Java — 传统线程/Executor
ExecutorService executor = Executors.newSingleThreadExecutor();
executor.execute(() -> {
    try {
        String result = api.getData();
        runOnUiThread(() -> textView.setText(result));
    } catch (Exception e) { }
});

// Kotlin — 协程
viewModelScope.launch {
    val data = withContext(Dispatchers.IO) { api.getData() }
    withContext(Dispatchers.Main) {
        textView.text = data
    }
}

// async + await 并行
viewModelScope.launch {
    val user = async { api.getUser() }
    val posts = async { api.getPosts() }
    combine(user.await(), posts.await()) { u, p -> ... }
}

// Flow 冷流
fun getUsers(): Flow<List<User>> = flow {
    emit(api.getUsers())
}.flowOn(Dispatchers.IO)

---

常用操作符速查

操作符	Java	Kotlin
判空默认值	? :	?:
安全调用	手动判空	?.
非空断言	—	!!
引用比较	==	===
值比较	.equals()	==
范围	>= && <=	.. / in
类型判断	instanceof	is
类型转换	(Type)	as / as?
位运算	& | ^	and() or() xor()