Java与kotlin比较

区别

1. 空安全（Null Safety）

// Kotlin 强制处理空值
var name: String? = null
val length = name?.length ?: 0 // 安全调用和 Elvis 操作符

// Java 允许直接空指针
String name = null;
int length = name.length(); // 运行时抛出 NullPointerException

---

2. 数据类（Data Class）

data class User(val name: String, val age: Int) // 自动生成 toString/equals/hashCode

// Java 需手动实现
public class User {
    private String name;
    private int age;
    // 需要手写构造函数、getter/setter、equals、hashCode、toString
}

---

3. 类型推断

val name = "Kotlin" // 自动推断为 String

var name = "Java"; // Java 10+ 支持 `var`，但类型推断范围更小

---

4. 函数定义

fun sum(a: Int, b: Int): Int = a + b // 单表达式函数

int sum(int a, int b) { return a + b; }

---

5. 默认参数和命名参数

fun greet(name: String = "World") { println("Hello, $name") }
greet(name = "Kotlin") // 命名参数

// Java 不支持，需通过方法重载模拟
void greet() { greet("World"); }
void greet(String name) { System.out.println("Hello, " + name); }

---

6. 扩展函数

fun String.reverse() = this.reversed()
val result = "abc".reverse() // "cba"

// Java 需通过工具类实现
public class StringUtils {
    public static String reverse(String s) { return new StringBuilder(s).reverse().toString(); }
}
String result = StringUtils.reverse("abc");

---

7. 字符串模板

val name = "Kotlin"
println("Hello, $name") // 直接嵌入变量

String name = "Java";
System.out.println("Hello, " + name);

---

8. 属性访问

class Person(var name: String) // 直接访问属性
val p = Person("Tom")
p.name = "Jerry"

public class Person {
    private String name;
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
}
Person p = new Person();
p.setName("Jerry");

---

9. 智能类型转换

if (obj is String) {
    println(obj.length) // 自动转换为 String
}

if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.length());
}

---

10. 区间表达式

for (i in 1..10) { /* 1到10 */ }
if (5 in 1..10) { /* true */ }

// Java 需手动实现循环或使用第三方库
for (int i = 1; i <= 10; i++) {}

---

11. 集合操作

val list = listOf(1, 2, 3)
val doubled = list.map { it * 2 } // [2, 4, 6]

List<Integer> list = List.of(1, 2, 3);
List<Integer> doubled = list.stream().map(i -> i * 2).collect(Collectors.toList());

---

12. 协程（Coroutine）

suspend fun fetchData() {
    val data = withContext(Dispatchers.IO) { /* 异步操作 */ }
}

// Java 需用线程或 CompletableFuture
CompletableFuture.supplyAsync(() -> /* 异步操作 */);

---

13. 对象声明（单例）

object Singleton { fun doWork() {} }
Singleton.doWork()

// Java 需手动实现单例
public class Singleton {
    private static Singleton instance = new Singleton();
    public static Singleton getInstance() { return instance; }
    private Singleton() {}
}
Singleton.getInstance().doWork();

---

14. 伴生对象（替代静态成员）

class MyClass {
    companion object { fun create() = MyClass() }
}
val obj = MyClass.create()

public class MyClass {
    public static MyClass create() { return new MyClass(); }
}
MyClass obj = MyClass.create();

---

15. 主构造函数

class Person(val name: String, val age: Int)

public class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

---

16. 初始化块

class InitDemo {
    init { println("初始化块") }
}

public class InitDemo {
    { System.out.println("初始化块"); }
}

---

17. 解构声明

val (name, age) = Person("Tom", 20)

// Java 需手动解构
Person p = new Person("Tom", 20);
String name = p.getName();
int age = p.getAge();

---

18. 内联函数（性能优化）

inline fun measureTime(block: () -> Unit) {
    val start = System.currentTimeMillis()
    block()
    println("Time: ${System.currentTimeMillis() - start}ms")
}

---

19. 密封类（Sealed Class）

sealed class Result
data class Success(val data: String) : Result()
data class Error(val msg: String) : Result()

// Java 需通过抽象类和继承模拟
public abstract class Result {}
public class Success extends Result { private String data; }
public class Error extends Result { private String msg; }

---

20. 类型别名

typealias NameList = List<String>

// Java 不支持类型别名

---

21. 委托属性

class DelegateExample {
    var value: String by lazy { "Lazy Initialized" }
}

---

22. 函数式接口

fun interface Runnable {
    fun run()
}

@FunctionalInterface
public interface Runnable {
    void run();
}

---

23. 运算符重载

data class Point(val x: Int, val y: Int) {
    operator fun plus(other: Point) = Point(x + other.x, y + other.y)
}
val p3 = Point(1, 2) + Point(3, 4)

// Java 不支持运算符重载

---

24. 尾递归优化

tailrec fun factorial(n: Int, acc: Int = 1): Int {
    return if (n == 0) acc else factorial(n - 1, acc * n)
}

---

25. 反射

val kClass = MyClass::class

Class<?> clazz = MyClass.class;

---

26. 注解处理

@Deprecated("Use newMethod instead")
fun oldMethod() {}

@Deprecated(since = "1.0", forRemoval = true)
public void oldMethod() {}

---

27. 检查异常

// Kotlin 无检查异常
fun readFile() {
    try { /* 读取文件 */ }
    catch (e: IOException) { /* 处理异常 */ }
}

// Java 强制处理检查异常
public void readFile() throws IOException {
    // 可能抛出 IOException
}

---

28. 协程作用域函数

CoroutineScope(Dispatchers.Main).launch { /* 协程代码 */ }

---

29. 构建 DSL

// Kotlin 可通过高阶函数构建 DSL
html {
    body { /* 嵌套结构 */ }
}

---

30. 委托模式

class PrinterDelegate(val printer: Printer) : Printer by printer

---

31. 内联集合操作

list.filter { it > 0 }.forEach { println(it) }

list.stream().filter(i -> i > 0).forEach(System.out::println);

---

32. 接口默认方法

interface MyInterface {
    fun defaultMethod() { println("Default") }
}

public interface MyInterface {
    default void defaultMethod() { System.out.println("Default"); }
}

---

33. 泛型差异

// Kotlin 使用 `out` 和 `in` 协变/逆变
class Box<out T>(val value: T)

// Java 使用通配符
class Box<T> { T value; }
Box<? extends Number> box = new Box<Integer>();

---

34. 延迟初始化

lateinit var lateInitialized: String

// Java 需手动管理
private String lateInitialized;
public void init(String value) { this.lateInitialized = value; }

---

35. 多行字符串

val text = """
    Line 1
    Line 2
""".trimIndent()

String text = "Line 1\nLine 2";

---

36. 类型检查

when (obj) {
    is String -> println(obj.length)
    is Int -> println(obj + 1)
}

if (obj instanceof String) {
    System.out.println(((String) obj).length());
} else if (obj instanceof Integer) {
    System.out.println((Integer) obj + 1);
}

---

37. 函数作为参数

fun process(block: (Int) -> String) { block(42) }
process { it.toString() }

void process(Function<Integer, String> block) { block.apply(42); }
process(i -> i.toString());

---

38. 内联类（Value Class）

@JvmInline value class Password(val value: String)

---

39. 作用域函数（let/apply）

val result = "hello".let { it.length }.apply { println(this) }

---

40. 重命名导入

import com.example.MyClass as Alias

import com.example.MyClass; // Java 不支持重命名

---

41. 类型投影（泛型通配符）

fun copy(from: Array<out Any>, to: Array<Any>) { /* ... */ }

void copy(Array<? extends Object> from, Array<Object> to) {}

---

42. 原始类型（Java 特有）

List list = new ArrayList(); // 原始类型（无泛型）

// Kotlin 强制泛型
val list: List<Any> = ArrayList()

---

43. 自动装箱

val number: Int? = null // 可空基本类型（自动装箱）

Integer number = null; // Java 显式装箱

---

44. 注解数组

@Annotation(arrayOf("a", "b"))

@Annotation({"a", "b"})

---

45. SAM 转换

val runnable = Runnable { println("SAM") }

Runnable runnable = () -> System.out.println("SAM");

---

46. 平台类型（互操作风险）

val javaString: String! = JavaClass.getString() // 可能为 null

---

47. 显式类型转换

val number = 42
val longNumber = number.toLong()

int number = 42;
long longNumber = (long) number;

---

48. JNI 支持

public native void nativeMethod(); // Java 直接支持

external fun nativeMethod() // Kotlin 通过 `external` 关键字

---

49. 构建器模式

// Kotlin 通过默认参数和命名参数简化
class Car(val color: String, val wheels: Int = 4)

// Java 需手写 Builder 类
Car car = new CarBuilder().setColor("Red").setWheels(4).build();

---

50. 跨平台支持

// Kotlin Multiplatform 允许共享代码
expect fun platformName(): String
actual fun platformName() = "JVM"

// Java 无原生跨平台支持

---

51. when 表达式 vs switch

val result = when (x) {
    is String -> "String: $x"
    in 1..10 -> "Number in range"
    else -> "Other"
} // 支持类型检查、范围、直接返回值

String result;
switch (x) {
    case "A": result = "Case A"; break;
    default: result = "Unknown";
} // 仅支持常量值

---

52. 构造器重载

class Person(val name: String) {
    constructor(age: Int) : this("Unknown") { /* 次构造器 */ }
}

public class Person {
    private String name;
    public Person(String name) { this.name = name; }
    public Person(int age) { this.name = "Unknown"; } // 需手动重载
}

---

53. 属性委托（Observable）

var name: String by Delegates.observable("") { _, old, new ->
    println("$old → $new")
}

// Java 需手动实现观察者模式
private String name;
public void setName(String name) {
    String old = this.name;
    this.name = name;
    System.out.println(old + " → " + name);
}

---

54. 接口属性

interface Animal {
    val legs: Int // 接口中声明属性
}
class Dog(override val legs: Int) : Animal

public interface Animal {
    int getLegs(); // 需通过方法模拟属性
}
class Dog implements Animal {
    private int legs;
    public int getLegs() { return legs; }
}

---

55. @JvmStatic 注解

class Utils {
    companion object {
        @JvmStatic fun help() {}
    }
}

// Java 调用
Utils.help(); // 无注解时需用 Utils.Companion.help();

---

56. 异常捕获

try { /* ... */ }
catch (e: IOException) { /* 必须显式捕获指定异常 */ }

try { /* ... */ }
catch (Exception e) { /* 可捕获所有异常（不推荐） */ }

---

57. internal 访问修饰符

internal class MyInternalClass // 模块内可见

// Java 无等价修饰符，通常用包级私有或文档约定

---

58. 函数式接口简化

val runnable = Runnable { println("Run") } // SAM 转换

Runnable runnable = () -> System.out.println("Run");

---

59. 集合字面量

val list = listOf(1, 2, 3)
val map = mapOf("a" to 1, "b" to 2)

List<Integer> list = List.of(1, 2, 3);
Map<String, Integer> map = Map.of("a", 1, "b", 2); // Java 9+

---

60. @JvmOverloads 注解

@JvmOverloads
fun greet(name: String = "World") {}

// 生成重载方法：greet() 和 greet(String name)

---

61. 类型检查与转换

if (obj is String && obj.length > 0) { /* 智能转换 */ }

if (obj instanceof String && ((String) obj).length() > 0) {}

---

62. inline 高阶函数

inline fun lock(block: () -> Unit) {
    synchronized(lock) { block() }
}

// Java 无内联支持，Lambda 会有匿名类开销

---

63. crossinline 和 noinline

inline fun example(crossinline block: () -> Unit, noinline ignored: () -> Unit) {}

---

64. reified 类型参数

inline fun <reified T> parse(json: String): T {
    return Gson().fromJson(json, T::class.java)
}

// Java 需传递 Class<T> 类型
public <T> T parse(String json, Class<T> type) {
    return new Gson().fromJson(json, type);
}

---

65. @JvmName 注解

@file:JvmName("MyUtils")
fun helper() {}

// Java 调用：MyUtils.helper();

---

66. use 资源管理

File("test.txt").bufferedReader().use { it.readText() }

try (BufferedReader br = new BufferedReader(new FileReader("test.txt"))) {
    br.read();
} // Java 7+ try-with-resources

---

67. 属性扩展

val File.content: String get() = readText()

// Java 需用工具类
public class FileUtils {
    public static String getContent(File file) { /* ... */ }
}

---

68. @Parcelize 注解

@Parcelize
data class User(val name: String) : Parcelable

// Java 需手动实现 Parcelable
public class User implements Parcelable {
    // 手写 CREATOR、describeContents、writeToParcel
}

---

69. @JvmField 注解

class User {
    @JvmField val name = "Kotlin"
}

// Java 直接访问字段：user.name

---

70. 密封接口（Sealed Interface）

sealed interface Result
class Success : Result
class Error : Result

// Java 15+ 支持密封类
public sealed interface Result permits Success, Error {}

---

71. invoke 运算符

class Adder {
    operator fun invoke(x: Int, y: Int) = x + y
}
val sum = Adder()(1, 2) // 3

// Java 需显式调用方法
int sum = new Adder().add(1, 2);

---

72. 属性延迟初始化

lateinit var data: String

// Java 需手动检查初始化状态
private String data;
public void setData(String data) { this.data = data; }
public String getData() { return data; }

---

73. 委托类（Class Delegation）

class MyList<T>(private val inner: List<T>) : List<T> by inner

---

74. @Throws 注解

@Throws(IOException::class)
fun readFile() { /* ... */ }

public void readFile() throws IOException {}

---

75. Nothing 类型

fun fail(): Nothing = throw Exception()

// Java 无等价类型，返回 `void` 或抛出异常
void fail() { throw new Exception(); }

---

76. 集合类型别名

typealias IntList = List<Int>

// Java 不支持类型别名

---

77. @JvmSynthetic 注解

@JvmSynthetic
fun hiddenFromJava() {}

---

78. @JvmRecord 注解

@JvmRecord
data class Point(val x: Int, val y: Int)

// Java 14+ 原生记录类
public record Point(int x, int y) {}

---

79. 显式类型投影

fun copy(from: Array<out Any>, to: Array<Any>) {}

---

80. @DslMarker 注解

@DslMarker
annotation class HtmlDsl

---

81. 接收者类型函数字面量

val sum: Int.(Int) -> Int = { other -> this + other }
val result = 1.sum(2) // 3

---

82. @OptIn 注解

@OptIn(ExperimentalCoroutinesApi::class)
fun useExperimentalApi() {}

---

83. @JvmWildcard 和 @JvmSuppressWildcards

fun test(): List<@JvmWildcard String> = listOf("A")

---

84. @SharedImmutable 注解（Kotlin/Native）

@SharedImmutable
val globalData = mutableListOf<String>()

---

85. expect/actual 多平台声明

// 公共模块
expect fun getPlatformName(): String

// JVM 实现
actual fun getPlatformName() = "JVM"

---

86. typeOf() 函数

val type = typeOf<List<String>>()

---

87. @JvmDefault 注解（兼容 Java 8 默认方法）

interface MyInterface {
    @JvmDefault
    fun defaultMethod() {}
}

---

88. @JsName 注解（Kotlin/JS）

@JsName("customName")
fun jsFunction() {}

---

89. @Experimental 注解

@Experimental(ExperimentalStdlibApi::class)
fun useNewApi() {}

---

90. @JvmInline 注解（值类）

@JvmInline
value class Password(val value: String)

---

91. 动态类型（Kotlin/JS）

val dyn: dynamic = js("{}")
dyn.name = "Kotlin"

---

92. @JvmMultifileClass 注解

// File1.kt
@file:JvmName("Utils")
package com.example

fun a() {}

// File2.kt
@file:JvmName("Utils")
package com.example

fun b() {}

---

93. @Target 注解的灵活性

@Target(AnnotationTarget.FIELD, AnnotationTarget.PROPERTY)
annotation class MyAnnotation

---

94. @Repeatable 注解

@Repeatable
annotation class Tag(val name: String)

@Tag("A") @Tag("B")
class MyClass

---

95. @JvmRecord 与数据类互操作

@JvmRecord
data class Point(val x: Int, val y: Int)

// Java 可当作记录类使用
Point point = new Point(1, 2);

---

96. @DeprecatedSinceKotlin 注解

@DeprecatedSinceKotlin(warningSince = "1.5")
fun oldFun() {}

---

97. @JvmSuppressWildcards 注解

fun suppressWildcards(list: List<@JvmSuppressWildcards String>) {}

---

98. @BackingField 注解

var counter = 0
    set(value) { field = value } // 使用幕后字段

---

99. @JvmName 用于扩展函数

@file:JvmName("StringUtils")
fun String.reverse() = this.reversed()

---

100. Kotlin/JS 的 external 声明

external fun alert(message: String) // 调用 JavaScript API

---

使用Kotlin原因

语言特性优势

1. 空安全设计

   var name: String? = null // 必须显式声明可空
   val length = name?.length ?: 0 // 避免 NullPointerException
   

   Java 中 String name = null; 直接使用可能崩溃。

2. 数据类（一行代码替代 Java 的 POJO）

   data class User(val name: String, val age: Int) // 自动生成 toString/equals/hashCode
   

   Java 需手写大量模板代码。

3. 扩展函数（无需继承增强类功能）

   fun Context.showToast(text: String) = Toast.makeText(this, text, Toast.LENGTH_SHORT).show()
   activity.showToast("Hello")
   

   Java 需通过工具类或继承实现。

4. 默认参数和命名参数

   fun loadImage(url: String, retries: Int = 3) { ... }
   loadImage("https://...", retries = 5) // 清晰指定参数
   

   Java 需通过方法重载模拟。

5. 更简洁的集合操作

   val filtered = list.filter { it > 0 }.map { it * 2 }
   

   Java 需 Stream API 且语法冗长。

6. 智能类型转换

   if (obj is String) println(obj.length) // 自动转换类型
   

   Java 需显式 (String) obj 并处理异常。

7. 协程（简化异步代码）

   viewModelScope.launch {
       val data = withContext(Dispatchers.IO) { fetchData() }
       updateUI(data)
   }
   

   Java 需回调或 CompletableFuture，代码嵌套严重。

8. 属性访问器（直接替代 Getter/Setter）

   class User(var name: String) // 直接访问属性
   user.name = "Kotlin"
   

   Java 需手写 getName()/setName()。

9. 委托属性（如 lazy 延迟初始化）

   val heavyObject by lazy { HeavyObject() } // 首次访问时初始化
   

   Java 需双重检查锁或静态初始化。

10. 密封类（限制继承结构）

    sealed class Result {
        data class Success(val data: Data) : Result()
        data class Error(val msg: String) : Result()
    }
    when (result) { ... } // 分支覆盖检查
    

    Java 需枚举或抽象类模拟。

---

开发效率提升

11. 更少的代码量（平均减少 40% 代码行）
    Kotlin 语法简洁，例如 Lambda 表达式、单表达式函数。

12. 字符串模板

    val message = "User $name has ${items.size} items"
    

    Java 需 String.format() 或 + 拼接。

13. 区间表达式

    for (i in 1..10) { ... }
    if (score in 60..100) { ... }
    

    Java 需 for (int i=1; i<=10; i++)。

14. 类型推断

    val name = "Kotlin" // 自动推断为 String
    

    Java 需显式声明类型（除非使用 var）。

15. 主构造函数和初始化块

    class User(val id: Int) { init { ... } }
    

    Java 需手写构造函数。

16. 解构声明

    val (name, age) = user
    

    Java 需手动提取字段。

17. 函数式编程支持

    listOf(1, 2, 3).fold(0) { acc, i -> acc + i }
    

    Java 需 Stream API（版本 8+）。

18. 内联函数（提升高阶函数性能）

    inline fun measureTime(block: () -> Unit) { ... }
    

    Java Lambda 会有匿名类开销。

19. 作用域函数（let/apply/run）

    user?.let { sendRequest(it) } // 安全调用链
    

20. when 表达式（强于 switch）

    when (x) {
        is String -> "String"
        in 1..10 -> "Number"
        else -> "Unknown"
    }
    

---

工具与生态支持

21. Jetpack Compose 首选语言
    Google 的现代 UI 框架 Compose 深度集成 Kotlin。

22. Android KTX 扩展库

    view.doOnClick { ... } // 替代 Java 的 View.OnClickListener
    

23. 与 Java 100% 互操作
    Kotlin 可直接调用 Java 代码，反之亦然。

24. Android Studio 原生支持
    自动转换 Java 代码到 Kotlin（菜单 Code → Convert）。

25. 更快的编译速度（Kotlin 1.5+）
    Kotlin 增量编译和 KAPT 优化缩短构建时间。

26. 官方推荐（Google I/O 2017 起）
    Google 宣布 Kotlin 为 Android 开发一级语言。

27. 丰富的社区资源
    Kotlin 的 Stack Overflow 问题解决率更高。

28. 跨平台开发（KMM）
    使用 Kotlin 开发 iOS、Web 和后端，共享业务逻辑。

29. 更少的样板代码
    Kotlin 自动生成 equals()/hashCode() 等方法。

30. 对 Java 8+ 特性的向后兼容
    Kotlin 支持 Lambda、方法引用等，无需关心 Android 版本。

---

安全性与维护性

31. 强制处理可空类型
    编译器阻止可能的空指针崩溃。

32. 不可变变量（val）

    val list = mutableListOf<String>() // 引用不可变，内容可变
    

    Java 需 final 但无法限制集合内容。

33. 类型系统更严格
    例如：区分 List 和 MutableList。

34. @Experimental 注解标记不稳定 API
    明确提示开发者风险。

35. 默认类和方法为 final
    避免 Java 中无意的继承导致设计问题。

36. 内部可见性（internal）
    模块级封装，替代 Java 的包级私有。

37. 无检查异常
    减少不必要的 try-catch 代码块。

38. 委托模式（防止继承滥用）

    class MyList<T>(private val inner: List<T>) : List<T> by inner
    

39. 密封接口（限制实现）
    Kotlin 1.5+ 支持密封接口，增强设计约束。

40. 协程结构化并发
    自动取消子任务，避免内存泄漏。

---

未来趋势与社区

41. Java 停滞，Kotlin 持续进化
    Kotlin 每年发布新特性（如 1.9 的跨平台上下文接收者）。

42. Kotlin 优先的库和框架
    如 Ktor、Exposed 等框架原生支持 Kotlin。

43. Google Play 上 70% 的 Top 1000 App 使用 Kotlin
    行业事实标准。

44. 更活跃的社区贡献
    Kotlin 在 GitHub 的 Star 数远超 Java 新项目。

45. JetBrains 强力支持
    IntelliJ 深度优化 Kotlin 的 IDE 体验。

46. Kotlin 多平台（KMP）的崛起
    一套代码适配 Android、iOS、桌面和 Web。

47. 更好的函数式编程支持
    如尾递归优化、内联类等。

48. 现代语言特性（如协程 Flow）

    val dataFlow = flow { emit(fetchData()) }
    

49. 更少的全局静态方法
    通过扩展函数替代 Java 的 Utils 类。

50. 开发者体验（DX）优先
    Kotlin 设计目标是为开发者提供愉悦的编码体验。

---