Java Core
trong một trang

JDK, JRE, JVM khác nhau thế nào

Từ source tới lúc chạy

Bytecode là ngôn ngữ trung gian cho JVM, không phải mã máy của CPU. Nhờ vậy cùng một file .class chạy được trên Windows, Linux, macOS — miễn có JVM tương thích.

Vì sao Java “write once, run anywhere”

• javac chỉ dịch tới bytecode, không gắn với CPU
• JVM chịu trách nhiệm hiểu bytecode trên từng nền tảng
• JIT biên dịch phần “nóng” thành mã máy tại thời điểm chạy
• Hệ quả: khởi động chậm hơn native, nhưng tối ưu dần theo profile thực tế

Ba câu mở đầu hay gặp

1. JVM, JRE, JDK khác gì nhau?
2. Vì sao Java chạy được đa nền tảng?
3. Java biên dịch hay thông dịch?

Gợi ý: Java là cả hai — javac biên dịch trước sang bytecode, JVM thông dịch lúc chạy và JIT biên dịch nóng sang mã máy.

Thuật ngữ nên dùng đúng

Stack vs Heap — lỗi đi kèm

• Stack: nhỏ, tự động thu hồi khi method return, chứa primitive và reference
• Heap: lớn, cấp phát object, GC mới thu hồi
• StackOverflow là Error; hết heap là OutOfMemoryError

Class loading

Parent delegation: Bootstrap → Platform → Application. Nhờ đó không thể ghi đè java.lang.String bằng class tự viết, và tránh nạp trùng.

Thứ tự khởi tạo — câu hỏi kinh điển

Static block chạy một lần khi class được khởi tạo (cha trước con). Instance initializer + field chạy trước constructor, cũng cha trước con.

GC: cách nghĩ đúng

• GC tìm object không còn reachable từ GC root (biến stack, static, thread, JNI)
• Không phải “đếm reference” — vòng tham chiếu vẫn bị thu hồi
• Heap chia thế hệ: object mới ở Young, sống lâu được promote lên Old
• Minor GC (Young) nhanh, thường stop-the-world rất ngắn; Major/Full GC đắt

JIT và tối ưu lúc chạy

• Ban đầu JVM thông dịch bytecode
• Method “nóng” được C1 (nhanh, ít tối ưu) rồi C2 (tối ưu sâu) biên dịch
• Tiered compilation bật mặc định; có thể deoptimize nếu giả định sai
• Escape analysis cho phép cấp phát object trên stack hoặc bỏ hẳn nếu không thoát ra ngoài
• Vì vậy micro-benchmark phải dùng JMH, không đo bằng System.nanoTime() thủ công

Công cụ chẩn đoán nên biết

Khi bị OutOfMemoryError, bật heap dump tự động rồi phân tích bằng Eclipse MAT hoặc VisualVM.

Các loại OOM thường gặp

• Java heap space — rò rỉ bộ nhớ hoặc heap quá nhỏ
• Metaspace — sinh class liên tục (proxy, script engine, hot reload)
• GC overhead limit exceeded — GC chạy quá nhiều mà thu hồi quá ít
• Direct buffer memory — NIO ByteBuffer.allocateDirect không được GC kịp
• unable to create native thread — quá nhiều thread hoặc hết bộ nhớ native

8 kiểu nguyên thuỷ

Không có kiểu unsigned (trừ char); Java 8 thêm Integer.toUnsignedString, compareUnsigned…

Wrapper, autoboxing và Integer cache

== và equals

String, wrapper, BigDecimal, enum, record đều đã override equals. Class tự viết thì phải tự làm.

Java luôn pass-by-value

Với object, Java copy giá trị của tham chiếu. Vì vậy sửa nội dung object thì thấy được, nhưng gán lại biến tham chiếu thì không ảnh hưởng bên ngoài.

Class immutable — công thức

• final class, field private final, không setter
• Copy phòng vệ khi nhận và khi trả collection/array/mutable object
• Immutable tự động thread-safe, an toàn làm key của map

final · finally · finalize

static — bốn cách dùng

• Field: thuộc class, dùng chung mọi instance
• Method: không có this, không override được (chỉ hiding)
• Block: chạy một lần khi class được khởi tạo
• Nested class: không giữ tham chiếu ngầm tới instance ngoài
• Import static: gọi trực tiếp hằng số/method

BigDecimal — tiền phải dùng kiểu này

• Luôn dùng constructor nhận String hoặc valueOf
• Chia phải chỉ định scale + RoundingMode, nếu không có thể ném ArithmeticException
• So sánh bằng compareTo == 0, không dùng equals

var — chỉ là suy luận kiểu

var chỉ dùng cho biến local, tham số lambda, biến vòng lặp. Không dùng cho field, tham số method hay kiểu trả về. Đây là static typing, không phải dynamic typing.

Tràn số, chia và ép kiểu

Overloading vs Overriding

Chọn overload nào?

Thứ tự ưu tiên: khớp chính xác → widening primitive → boxing → varargs. Tránh overload chỉ khác wrapper/primitive vì rất dễ gọi nhầm.

Abstract class vs Interface

Nguyên tắc thực dụng: interface để định nghĩa kiểu, abstract class để tái sử dụng phần chung. Ưu tiên interface vì không khóa cây kế thừa.

Default method và xung đột hình thoi

• Class thắng interface: method trong class cha luôn được ưu tiên
• Hai interface: interface “cụ thể hơn” (extends interface kia) thắng
• Không phân định được → bắt buộc override, có thể gọi X.super.method()

Constructor: this(), super() và bẫy gọi virtual

equals và hashCode

• a.equals(b) → a.hashCode() == b.hashCode() (bắt buộc)
• Hash bằng nhau không suy ra equals
• Field dùng trong equals phải giữ nguyên — đổi sau khi put vào HashSet sẽ “mất” phần tử
• Override equals mà quên hashCode: HashMap/HashSet hoạt động sai

Class lồng nhau

enum — không chỉ là hằng số

• Enum ngầm kế thừa java.lang.Enum, không extends class khác, nhưng implement interface được
• Có values(), valueOf(), name(), ordinal(); so sánh bằng ==
• Enum singleton an toàn trước serialization và reflection — cách làm singleton được khuyên dùng

Composition thay vì kế thừa

Kế thừa làm lớp con phụ thuộc vào cài đặt của lớp cha (fragile base class). Chỉ kế thừa khi thật sự is-a và lớp cha được thiết kế để kế thừa.

SOLID trong một dòng

Đừng học thuộc; hãy gắn mỗi nguyên tắc với một ví dụ bạn đã từng sửa code.

Vì sao String immutable?

• An toàn chia sẻ giữa các thread, không cần đồng bộ
• Cho phép string pool: nhiều biến cùng trỏ một object, tiết kiệm bộ nhớ
• An toàn khi dùng làm key HashMap hoặc tham số bảo mật (đường dẫn, SQL)
• HashCode được cache — tính một lần

Pool và intern()

Chuỗi nối từ hằng số biên dịch cũng vào pool: "a" + "b" tương đương literal "ab". Nhưng nối với biến thì tính lúc chạy, ra object mới.

Cộng chuỗi trong vòng lặp

• + trong một biểu thức được javac dịch thành StringBuilder — ổn
• += trong vòng lặp tạo StringBuilder mới mỗi lần — rất tốn
• StringBuilder: nhanh, không đồng bộ; StringBuffer: có synchronized, chậm hơn
• Đặt capacity trước nếu biết độ dài gần đúng

API String nên nhớ

Text block

• """ mở phải xuống dòng ngay
• Thụt lề chung nhỏ nhất bị loại bỏ (incidental whitespace)
• \ cuối dòng để nối, \s để giữ khoảng trắng cuối
• Dùng """...""".formatted(x) thay vì nối chuỗi

Những bẫy nhỏ nhưng hay hỏi

Unicode: length không phải số ký tự

Xử lý văn bản người dùng: dùng codePointCount, Normalizer, và BreakIterator khi cắt theo từ.

Ghép chuỗi có delimiter

Đừng nối bằng vòng lặp và tự xử lý dấu phẩy — dễ thừa/thiếu delimiter ở đầu/cuối.

ArrayList vs LinkedList

Thực tế: mặc định dùng ArrayList. LinkedList chỉ hơn khi chèn/xóa ở hai đầu — mà việc đó ArrayDeque làm tốt hơn.

ArrayList bên trong

• Mảng Object[] elementData + size riêng
• Capacity mặc định 10, nhưng chỉ cấp phát ở lần add đầu tiên
• Khi đầy: tăng khoảng 1.5 lần (old + (old >> 1)) rồi Arrays.copyOf
• trimToSize() thu gọn; ensureCapacity() giảm số lần cấp phát
• subList() là view, không phải bản copy — sửa view ảnh hưởng list gốc

LinkedHashMap làm LRU cache

LinkedHashMap giữ thứ tự chèn; với accessOrder = true nó đổi thứ tự mỗi lần get — đúng hành vi LRU.

HashSet, TreeSet, LinkedHashSet

HashSet thực chất bọc một HashMap với value giả. TreeSet dùng compareTo/Comparator để xác định trùng, không dùng equals.

Queue và Deque

Key hỏng làm hỏng HashMap

Comparable vs Comparator

• Comparable: “thứ tự tự nhiên” của class, một cách duy nhất
• Comparator: nhiều cách sắp xếp, truyền từ ngoài vào, không sửa class
• compareTo nên nhất quán với equals nếu dùng trong TreeSet/TreeMap

Fail-fast và xóa phần tử

Iterator so sánh modCount với giá trị lúc tạo và ném CME — cơ chế best-effort, không đảm bảo phát hiện mọi trường hợp.

“Không sửa được” có ba loại

Chọn nhanh

Với HashMap biết trước số phần tử, khởi tạo new HashMap<>(n * 4 / 3 + 1) để tránh resize.

Vì sao cần generics

Ba lợi ích: kiểm tra kiểu sớm, bỏ cast, API tự mô tả. Generics không tồn tại lúc runtime — đó là cái giá của tương thích ngược.

Type erasure — hệ quả

• Không biết kiểu generic lúc runtime → không thể new T()
• Không overload hai method chỉ khác type argument
• Không dùng primitive làm tham số kiểu — phải dùng wrapper
• Static member không dùng được type parameter của class
• Bù bằng Class<T>, TypeToken, hoặc factory method

Bounded type parameter

Chỉ một class bound và phải đứng đầu; sau đó là các interface. Nhờ bound, bên trong method gọi được method của kiểu giới hạn.

Generic method và suy luận kiểu

Compiler suy luận từ đối số và ngữ cảnh. Khi không suy ra được, chỉ định tường minh: Collections.<String>emptyList().

Bridge method — chuyện ít ai để ý

Do erasure, lớp cha thật sự có set(Object). Compiler tạo bridge để đảm bảo dispatch đúng — đó là lý do getDeclaredMethods() đôi khi thấy method “lạ”.

Heap pollution và @SafeVarargs

Wildcard capture

“Capture” là khi compiler tạm đặt tên cho kiểu chưa biết. Helper generic giúp chuyển List<?> thành List<T> để thao tác.

Checked vs Unchecked

try-with-resources

• Đóng theo thứ tự ngược lúc mở
• Exception khi đóng không mất — thành suppressed
• Chỉ nhận class implement AutoCloseable
• Viết ngắn hơn finally và không quên đóng khi có exception

Tự tạo exception

• Kế thừa RuntimeException cho lỗi nghiệp vụ; checked khi buộc caller xử lý
• Truyền cause để không mất stack trace gốc
• Đặt tên theo tình huống, không theo tầng (UserNotFoundException tốt hơn ServiceException)

Bắt và ném lại đúng cách

Exception hay gặp và nguyên nhân

Từ Java 14 (bật mặc định từ 15), NPE có “helpful message” chỉ rõ biểu thức nào null — hữu ích khi debug.

Quy tắc vàng khi xử lý lỗi

• Bắt cụ thể nhất có thể; tránh catch (Throwable)
• Không dùng exception cho luồng điều khiển bình thường
• Không để catch rỗng — nếu bỏ qua phải ghi lý do
• Wrap phải kèm cause
• Đóng tài nguyên bằng try-with-resources
• Message đủ ngữ cảnh nhưng không lộ mật khẩu/token
• Phân biệt lỗi “có thể thử lại” và “không thể” để retry đúng

Functional interface

Có thể có nhiều default/static method, nhưng chỉ một abstract method. @FunctionalInterface giúp compiler báo lỗi nếu bạn vô tình thêm method thứ hai.

Cú pháp và biến capture

Lambda không tạo scope mới cho this — this vẫn là instance bao ngoài (khác anonymous class). Biến local capture phải effectively final.

Method reference — 4 kiểu

Chỉ dùng khi method reference dễ đọc hơn lambda. Chuỗi :: lồng nhau quá sâu thì lambda rõ nghĩa hơn.

Ghép hàm

andThen xuôi chiều đọc, compose ngược chiều toán học. Với predicate có and, or, negate.

Optional — dùng đúng chỗ

• Dùng làm kiểu trả về khi “không có kết quả” là bình thường
• Không dùng cho field, tham số, collection phần tử
• Không gọi get() mà chưa kiểm tra
• map tự bọc, flatMap khi hàm đã trả Optional

orElse vs orElseGet

Optional trong stream

Optional.stream() (Java 9) là cách gọn nhất để lọc bỏ phần tử rỗng khi đang ở trong pipeline.

Tạo stream

Java 9 thêm Stream.iterate(seed, hasNext, next) — dừng được mà không cần limit.

Intermediate ops

Terminal ops

map vs flatMap

Chọn flatMap khi đã có sẵn collection/stream con. Chọn mapMulti khi cần sinh 0, 1 hoặc nhiều phần tử bằng code.

reduce — ba dạng

Primitive stream

Dùng mapToInt/mapToLong/mapToDouble để tránh boxing và có sẵn sum, average. Đừng lạm dụng IntStream.range khi for dễ đọc hơn.

takeWhile, dropWhile, sorted

takeWhile/dropWhile chỉ có ý nghĩa với stream có thứ tự; với stream không ordered, kết quả không xác định.

Ví dụ thực tế: top 3 lương theo phòng

Đọc từ trái sang phải như câu tiếng Việt: “lọc → sắp → lấy 3 → lấy tên”. Nếu pipeline dài quá 6 bước, tách thành method có tên.

Song song — chỉ khi đáng

• Mặc định dùng ForkJoinPool.commonPool(), size = số core − 1
• Chỉ lợi khi dữ liệu lớn, tác vụ CPU-bound, không chia sẻ trạng thái
• Không dùng cho I/O, blocking, hay list nhỏ (chi phí chia việc lớn hơn lợi ích)
• Không đảm bảo thứ tự với forEach; dùng forEachOrdered nếu cần
• Tránh collector có side effect; toMap song song phải có merge

Stream Gatherers (Java 24)

Gatherer là “intermediate op tự định nghĩa”, cho phép cửa sổ trượt, gộp dần, giới hạn concurrency — những thứ trước đây phải viết collector hoặc vòng lặp.

Bẫy stream hay gặp

• Dùng lại stream đã có terminal op → IllegalStateException
• Sửa collection nguồn trong lúc stream → CME hoặc kết quả sai
• toMap trùng key hoặc value null
• Stream vô hạn quên limit
• Dùng forEach để cộng dồn — hãy dùng reduce/collector
• Parallel + biến mutable chia sẻ
• Checked exception trong lambda → phải wrap thành unchecked
• peek để tạo side effect nghiệp vụ (chỉ nên để debug)

Trạng thái thread

Race condition và ba cách sửa

Hai thread cùng đọc 5, cùng ghi 6 → mất một lần tăng. synchronized đảm bảo cả visibility và atomicity; AtomicInteger dùng CAS, nhanh hơn khi tranh chấp thấp.

volatile vs synchronized vs Atomic

wait / notify / sleep / join

• wait() nhả monitor và chờ; sleep() không nhả
• wait/notify phải gọi trong khối synchronized trên cùng object
• join() chờ thread kia kết thúc
• Ưu tiên BlockingQueue hơn tự viết wait/notify

Chọn kích thước pool

Đừng đoán — đo tải thật rồi chỉnh. Pool quá nhỏ làm task xếp hàng; quá lớn gây context switch và tranh chấp.

CompletableFuture

• thenApply: hàm đồng bộ; thenApplyAsync: chạy trên pool
• thenCompose khi hàm trả CompletableFuture, tránh lồng CF<CF<T>>
• handle nhận cả kết quả và lỗi; exceptionally chỉ xử lý lỗi
• join() ném unchecked; get() ném checked
• Truyền executor cho tác vụ I/O, đừng dựa vào common pool

Deadlock

• Bốn điều kiện: loại trừ tương hỗ, giữ và chờ, không tước đoạt, chờ vòng tròn
• Phòng: sắp thứ tự lock cố định, dùng tryLock(timeout), giảm phạm vi lock
• Phát hiện: jstack <pid> tìm “Found one Java-level deadlock”
• Không gọi code bên ngoài (callback, listener) khi đang giữ lock

ThreadLocal và rò rỉ trong pool

Mỗi thread giữ một bản riêng — không phải cách chia sẻ dữ liệu. Trong pool, thread sống rất lâu nên giá trị cũ bị giữ lại và có thể rò rỉ qua ThreadLocalMap.

Structured concurrency (preview)

Ý tưởng: task con thuộc về một scope, cha chờ tất cả, lỗi một task hủy cả nhóm, không có thread “mồ côi”. Vẫn là preview ở Java 25.

JMM và double-checked locking

Thiếu volatile, phép gán có thể bị reorder: thread khác thấy instance != null nhưng object chưa khởi tạo xong. Đây là ví dụ kinh điển của safe publication.

Collection cho đa thread

Collections.synchronizedMap khoá cả map; ConcurrentHashMap chỉ khoá theo bucket nên throughput cao hơn nhiều.

Happens-before — bốn quan hệ cần nhớ

• Trong một thread: câu lệnh trước happens-before câu sau
• unlock của monitor happens-before lock kế tiếp trên cùng monitor
• Ghi volatile happens-before lần đọc volatile đó
• Thread.start() happens-before mọi thứ trong run(); mọi thứ trong thread happens-before join() trả về

Không có happens-before thì trình biên dịch/CPU được phép reorder và cache giá trị — đó là gốc của lỗi “chạy máy tôi thì đúng”.

Sealed — đóng cây kế thừa

Lớp con phải là final, sealed hoặc non-sealed. Lợi ích lớn nhất: compiler biết đầy đủ các subtype nên switch không cần default.

Pattern matching cho switch

• when là guard — thứ tự case có ý nghĩa
• case null phải khai báo nếu muốn bắt null, nếu không sẽ NPE
• Với sealed, bỏ default được và compiler kiểm tra đủ nhánh
• Record pattern deconstruct được cả record lồng nhau

instanceof pattern

Biến pattern chỉ tồn tại trong nhánh mà điều kiện đúng — compiler phân tích luồng chứ không chỉ scope.

Sequenced Collections (21)

Trước Java 21 phải dùng list.get(0), list.get(size-1), Deque… không thống nhất. Giờ SequencedCollection/Set/Map có hợp đồng chung.

Compact source file & instance main (25)

Dành cho người mới và script nhỏ. File vẫn biên dịch thành class ẩn; khi cần đóng gói nghiêm túc thì quay lại class thường. Đây là tính năng chính thức từ Java 25.

Module import (25)

Một dòng import thay cho hàng chục import java.util.*. Chỉ import package được module export, không phá encapsulation.

Flexible constructor body (25)

Trước đây super() bắt buộc là lệnh đầu tiên, muốn validate phải tách static helper. Giờ được phép đặt logic không dùng this trước super().

Đã bị loại bỏ / ngừng dùng

• Security Manager bị vô hiệu vĩnh viễn từ Java 24
• Port 32-bit x86 bị bỏ từ Java 25
• finalize() deprecated for removal — dùng Cleaner hoặc try-with-resources
• Thread.stop/suspend/resume không an toàn — đã bị vô hiệu, gọi sẽ ném UnsupportedOperationException
• java.util.Date/Calendar nên thay bằng java.time
• Java serialization không dành cho dữ liệu không tin cậy

Bốn nhóm stream

Cầu nối: InputStreamReader, OutputStreamWriter. Luôn bọc Buffered* khi đọc/ghi nhiều lần để giảm syscall.

java.nio.file — dùng hằng ngày

Nhớ đóng Files.lines/Files.walk (chúng giữ file handle). Từ Java 18, charset mặc định của JVM là UTF-8.

Java serialization

• Serializable là marker interface, không có method
• serialVersionUID lệch → InvalidClassException
• transient = bỏ qua khi serialize; static cũng không được serialize
• Deserialization có thể bị lợi dụng để chạy gadget chain → không nhận dữ liệu không tin cậy
• Thực tế: dùng JSON (Jackson) hoặc Protobuf cho API/lưu trữ

IO vs NIO

Với ứng dụng thông thường, Files + try-with-resources là đủ. Virtual thread giúp mô hình blocking truyền thống scale tốt hơn nhiều, nên NIO thuần ít cần hơn trước.

Nên

Tránh