Kotlin vs Java: Ngôn ngữ nào nên chọn cho Android vào năm 2026?

Kotlin không phải “Java viết ngắn hơn”, và Java cũng chưa chết trong Android. Năm 2026, câu trả lời ngắn gọn là: Kotlin là ngôn ngữ mặc định, Java là ngôn ngữ bạn phải đọc để làm việc với code cũ và SDK. Phần còn lại của bài này giải thích vì sao, kèm chi phí thật và cách chuyển đổi mà không phá app đang chạy.

Nếu bạn chỉ cần một câu để quyết định: dự án mới viết Kotlin, dự án cũ không rewrite chỉ vì ngôn ngữ. Nhưng để bảo vệ quyết định đó trong một buổi review kiến trúc, bạn cần hiểu cả hai phía.

Cập nhật 2026: năm điểm thay đổi cách so sánh

  • Kotlin 2.4.21 là bản stable (10/2026). K2 compiler là mặc định từ Kotlin 2.0, không còn “chế độ K2” để bật.
  • Kotlin 2.5.0 dự kiến ra 12/2026, chưa phát hành. Đừng pin nó như bản hiện tại.
  • KSP2 là annotation processor được hỗ trợ; KAPT vẫn chạy nhưng là legacy, chậm vì phải sinh javac stubs.
  • Compose compiler đi kèm Kotlin: version plugin Compose phải trùng version Kotlin, lệch một số là lỗi build khó đọc.
  • Không có chuyện javax vs jakarta trong Android. Đây là vấn đề của Java EE/backend. javax.inject mà Hilt dùng là JSR-330, không phải Java EE — đừng mang tranh luận backend sang app Android.

Vì sao Google chọn Kotlin — và vì sao năm 2026 lý do đó vẫn đúng

Google công bố hỗ trợ Kotlin chính thức tại I/O 2017, rồi đến 2019 gọi Kotlin là ngôn ngữ ưu tiên (Kotlin-first). Không có gì bí ẩn: Kotlin giảm số dòng code phải viết, giảm một lớp lỗi runtime, và cho phép Google viết thư viện mới bằng một ngôn ngữ biểu đạt hơn Java.

Hệ quả thực tế, không phải khẩu hiệu:

  • Tài liệu, codelab, sample và phần lớn nội dung mới trên developer.android.com viết bằng Kotlin.
  • Jetpack Compose là Kotlin-first, thậm chí Kotlin-only: Compose compiler là plugin của Kotlin compiler. Chọn Compose cho UI mới nghĩa là chọn Kotlin cho module UI đó.
  • AndroidX có các API thiết kế cho Kotlin (KTX, default parameter, lambda receiver), trong khi vẫn gọi được từ Java.
  • Lint và Android Studio có refactor, quick-fix, kiểm tra nullability tốt hơn cho Kotlin.

Điều Google không làm: xóa Java. javac vẫn biên dịch trong build Android, Android SDK vẫn là Java API, và không có API nào bị loại bỏ chỉ vì “Java là legacy”.

Cùng một model class: Java và Kotlin

Lấy một model nhỏ có một field có thể null. Yêu cầu: constructor, getter, equals, hashCode, toString, và giá trị mặc định cho field không bắt buộc.

// File: app/src/main/java/com/example/model/Task.java
public final class Task {
    private final String id;
    private final String title;
    private final String assignee; // có thể null
    private final boolean done;

    public Task(String id, String title, String assignee) {
        this(id, title, assignee, false);
    }

    public Task(String id, String title, String assignee, boolean done) {
        this.id = id;
        this.title = title;
        this.assignee = assignee;
        this.done = done;
    }

    public String getId() { return id; }
    public String getTitle() { return title; }
    public String getAssignee() { return assignee; }
    public boolean isDone() { return done; }

    // equals(), hashCode(), toString(): vài chục dòng nữa
}

Bản Java trên còn thiếu equals, hashCode, toString — nghĩa là khoảng 40–60 dòng nếu viết đầy đủ và đúng. Kotlin:

// File: app/src/main/kotlin/com/example/model/Task.kt
data class Task(
    val id: String,
    val title: String,
    val assignee: String? = null,
    val done: Boolean = false,
)

Bốn dòng thay cho cả class. data class sinh equals, hashCode, toString, copy và componentN; assignee: String? nói rõ field có thể null; = null là default argument, không cần constructor phụ. Ở call site Java bạn vẫn gọi được qua getter getId(), getAssignee(); Java không thấy default argument nếu bạn không thêm @JvmOverloads.

Null-safety không chỉ là ký tự ?. Trong Kotlin, assignee.length là lỗi compile, buộc bạn viết assignee?.length ?: 0 hoặc kiểm tra null trước. Trong Java, lỗi tương đương chỉ xuất hiện lúc runtime, thường là production, thường là của người dùng.

Với state phức tạp, sealed interface cộng when cho bạn tính đầy đủ do compiler kiểm tra:

sealed interface TaskState {
    data object Loading : TaskState
    data class Success(val tasks: List<Task>) : TaskState
    data class Error(val message: String) : TaskState
}

fun render(state: TaskState) = when (state) {
    TaskState.Loading -> showLoading()
    is TaskState.Success -> showTasks(state.tasks)
    is TaskState.Error -> showError(state.message)
}

Thêm case, compiler báo lỗi ngay tại when nếu bạn quên xử lý. Java cũng có sealed class (17) và pattern matching cho switch (21), nhưng toolchain Android hỗ trợ các mức ngôn ngữ mới qua desugaring với độ trễ — nên nhiều team vẫn dùng enum hoặc visitor cho state.

Lợi thế thật sự: ít code hơn và ít lỗi hơn

Ngoài data class và null-safety, ba thứ sau tiết kiệm thời gian mỗi ngày:

  • Coroutines và Flow. Structured concurrency: một scope, hủy là hủy cả cây. viewModelScope.launch, Flow, StateFlow thay cho callback lồng nhau, AsyncTask (deprecated từ API 30) và RxJava cho các case thông thường. Java có CompletableFuture và thread pool, nhưng cancellation và lifecycle vẫn là việc bạn phải tự nối.
  • Extension function và scope function. Thêm hành vi cho class bạn không sở hữu, không cần kế thừa; let, apply, also giữ code cấu hình ngắn mà vẫn đọc được.
  • Ngôn ngữ nhỏ hơn ở chỗ đúng. val mặc định khuyến khích immutability, smart cast bỏ ép kiểu thừa, default/named argument bỏ builder cho cấu hình đơn giản, string template bỏ nối chuỗi.

Không có lợi thế runtime: cả hai biên dịch ra JVM bytecode, D8 chuyển thành DEX, ART chạy cùng runtime. Chênh lệch hiệu năng đến từ kiến trúc, allocation và I/O, không từ tên ngôn ngữ.

Cái giá của Kotlin: build, tooling và con người

Kotlin không miễn phí. Ba chi phí thật:

  • Build time. Kotlin từng chậm hơn Java ở incremental build, nhất là khi có KAPT. K2 (từ 2.0) rút ngắn khoảng cách; KSP2 nhanh hơn KAPT rõ rệt; nhưng annotation processing vẫn là phần đắt nhất trong build Android. Đừng tin benchmark trên blog — đo trên project của bạn bằng --profile.
  • Tooling matrix. Kotlin 2.4.21, AGP 9.5, Gradle 9.9, JDK 17, Compose compiler trùng version Kotlin, KSP trùng version Kotlin. Lệch một ô là lỗi build hoặc lỗi KSP khó đọc. Dùng version catalog và đọc release notes thay vì copy số version từ Stack Overflow.
  • Kỹ năng team. Lập trình viên Java đọc Kotlin trong vài ngày, nhưng viết Kotlin idiomatic — Flow, DSL, Compose, không lạm dụng !! — mất vài tháng. Code review chậm hơn trong quý đầu; cần một người đủ kinh nghiệm để chặn “Java viết bằng cú pháp Kotlin”.

Java còn vai trò gì trong năm 2026?

Java không phải “ngôn ngữ của quá khứ” mà là ngôn ngữ của nền tảng:

  • Code cũ. Hàng trăm nghìn app Android có business logic Java. Đọc hiểu, sửa bug, thêm feature vào đó là công việc thật, không phải bài tập lịch sử.
  • SDK và thư viện bên thứ ba. Nhiều SDK quảng cáo, thanh toán, thiết bị vẫn phát hành API và sample bằng Java; một số annotation processor cũ chỉ chạy với KAPT.
  • Team enterprise. Chuẩn code, tuyển dụng, review, và đôi khi model dùng chung với backend Java. Đổi ngôn ngữ là đổi tổ chức, không chỉ đổi file.
  • Hiểu nền tảng. Android SDK là Java API; stack trace, reflection, android.jar và nhiều lỗi runtime vẫn cần đọc Java thành thạo.

“Java đã chết” là câu sai; nói với junior rằng không cần học Java là che đi một phần công việc của họ.

Tương tác 100%: đúng, nhưng có biên giới

Kotlin và Java gọi nhau hai chiều, kế thừa chéo, implement interface chéo, dùng chung thư viện. Cùng một project, cùng một module, cùng một file build. Đó là lý do migration từng phần khả thi.

Nhưng “100%” vẫn có ma sát ở vài điểm:

  • Platform type. Java trả về String! — Kotlin không biết nó có thể null hay không, nên null-safety không bảo vệ biên giới này. Thêm @Nullable/@NonNull (AndroidX đã làm) để compiler có thông tin.
  • Default argument không hiện với Java. Cần @JvmOverloads nếu muốn Java thấy các overload.
  • @JvmStatic, @JvmName, @Throws. Ba annotation này quyết định hình dạng API mà Java nhìn thấy; thiếu @Throws thì Java không thấy throws.
  • internal không phải private với Java. Trong bytecode nó là public với tên bị mangle; đừng dùng internal như hàng rào bảo mật trước Java.
  • Property thành getter/setter. val title thành getTitle(); đó là lý do Java đọc được Kotlin mà không cần biết Kotlin.

Chiến lược migration: module hỗn hợp, không rewrite tất cả

Nguyên tắc: chuyển đổi theo nơi bạn đang sửa, không theo lịch “toàn bộ codebase thành Kotlin”. Các bước:

  • Thêm Kotlin vào một module trước. Module leaf (data, domain, util) ít phụ thuộc UI, dễ test, rủi ro thấp. Không bắt đầu từ module app.
  • Code mới bằng Kotlin, code cũ giữ Java. Một policy rõ ràng — “không thêm file Java mới” — hiệu quả hơn một chiến dịch rewrite.
  • Chuyển một class khi bạn đã phải sửa nó. Converter của Android Studio tạo ra Kotlin chạy được nhưng thường không idiomatic; review từng file, đừng convert cả package rồi commit.
  • Test là lưới an toàn. Class cần có test trước khi convert; biên giới Java–Kotlin cần test riêng vì platform type và annotation sai rất khó thấy.
  • Đo và dừng đúng lúc. Theo dõi % dòng Kotlin, build time, crash rate. Nếu build chậm đi 20% sau khi thêm KAPT, đó là tín hiệu chuyển sang KSP2 chứ không phải bỏ Kotlin.

Đừng rewrite app đang chạy chỉ vì bạn thích ngôn ngữ. Rewrite không tạo ra user value, rủi ro regression cao, và thường mất 6–12 tháng — trong khi interop cho phép bạn hiện đại hóa từng phần ngay tuần này.

Bảng quyết định

Tình huống Chọn Lý do
App mới, không ràng buộc Kotlin + Compose Mặc định của Google; Compose là Kotlin-only; ít boilerplate.
App Java đang chạy, có người dùng Giữ Java, code mới Kotlin Interop 100%; rewrite không mang lại giá trị.
Team toàn Java, deadline gần Java trước, học Kotlin song song Năng suất ngắn hạn; đặt lộ trình 6–12 tháng, không ép chuyển ngay.
SDK chỉ có sample Java hoặc processor KAPT-only Module đó Java, phần còn lại Kotlin Chi phí biên giới thấp hơn chi phí bỏ SDK.
Muốn chia sẻ logic với iOS/backend Kotlin (KMP) Kotlin Multiplatform ổn định cho shared business logic.

Năm cái bẫy hay gặp

  1. “Java đã chết”. Sai. Android SDK, ART, thư viện và code cũ vẫn là Java. Hệ quả: junior bỏ Java sẽ không đọc được stack trace và SDK. Sửa: học Java đủ để đọc, không cần thành chuyên gia.
  2. Rewrite app đang chạy vì sở thích ngôn ngữ. Sửa: strangler pattern — code mới Kotlin, thay dần từng màn hình khi có việc phải sửa.
  3. Pin version mù. Kotlin 2.4.21 kéo theo Compose compiler 2.4.21 và một bản KSP tương ứng; AGP 9.5 cần Gradle 9.6+ và JDK 17. Đừng pin 2.5.0 vì nó mới là kế hoạch 12/2026.
  4. KAPT cho dự án mới. KAPT sinh javac stubs, chậm và là legacy. Dùng KSP2; nhưng KSP phải khớp Kotlin — bản 2.3.13 có lỗi concurrency đã biết, đừng pin theo blog.
  5. Tin null-safety tuyệt đối. !! và platform type từ Java vẫn tạo NPE. Sửa: ?., ?:, requireNotNull kèm thông điệp; annotate API cho Java gọi.

2026 và 2027: điều gì tiếp theo

K2 đã là mặc định, nên “bật K2 để build nhanh hơn” không còn là việc của năm 2026. Kotlin 2.5.0 dự kiến ra 12/2026 — theo dõi release notes thay vì pin trước. KMP và Compose Multiplatform đang mở rộng khỏi UI sang shared logic, điều này làm Kotlin có lý do tồn tại mạnh hơn cả trong app chỉ có Android.

Phía Java, không có cú lật nào: Java tiếp tục là ngôn ngữ của SDK và của code cũ, các tính năng mới của JDK đến qua desugaring với độ trễ nhất định. Còn javax vs jakarta vẫn là câu chuyện backend, không phải Android.

Checklist trước khi chốt

  • Chốt baseline: Kotlin 2.4.21, AGP 9.5, Gradle 9.9, JDK 17, compileSdk = 36.
  • Dự án mới: Kotlin + Compose + KSP2; không thêm KAPT.
  • Dự án cũ: thêm Kotlin plugin vào một module leaf trước, không sửa UI trước.
  • Viết policy “code mới Kotlin, không thêm file Java”, review hàng quý.
  • Kiểm tra version matrix (Kotlin / Compose compiler / KSP / AGP) trước khi thêm thư viện mới.
  • Đo build time trước/sau khi thêm Kotlin; chậm thì xử lý annotation processing trước.

Đọc tiếp trong series

Kết luận: năm 2026, Kotlin là mặc định vì đó là ngôn ngữ Google dùng để viết tương lai của Android, không phải vì Java hỏng. Java vẫn là kỹ năng đọc nền tảng và bảo trì code cũ. Chọn Kotlin cho việc mới, giữ Java cho việc đang chạy, và đừng rewrite chỉ vì bạn thích cú pháp.