Đến nội dung chính
notes.vinhnq.com

Tìm kiếm

Java CoreSenior21 phút đọc

Generics trong Java: type erasure, raw type và type token

Ôn 14 thẻ
Trong bài này

Cụm bài Generics trong Java: 1. Generic class, method, bounded type · 2. Wildcard và PECS · 3. Type erasure và type token

Phần 1 và 2 nói về những gì generics kiểm tra lúc compile. Phần 3 trả lời câu phỏng vấn senior rất hay hỏi: lúc chạy thì generics còn lại gì? Đọc xong, bạn giải thích được type erasure cùng các hệ quả của nó, lấy lại được kiểu lúc runtime bằng type token, và dùng generics với record, sealed interface (Java 17–21).

Nên đọc phần 1 (generic class, method, invariance) và phần 2 (wildcard, PECS) trước.

Sơ đồ tóm tắt:

flowchart LR
  S["List#lt;String#gt;"] -->|compiler kiểm tra| E[Erasure]
  E --> B["T → bound/Object + cast"]
  E --> BR[Bridge method]
  E --> RT["Runtime: cùng một class"]
  RT --> L["Không new T(), List#lt;int#gt;, instanceof"]
  E --> D["Khai báo trong .class còn giữ"]
  D --> TT[Type token]
  RAW["Raw type / unchecked cast"] -.->|bẫy| CCE["ClassCastException ở chỗ đọc"]

1. Type erasure

Ý chính: Java cài đặt generics bằng type erasure (xoá kiểu): compiler kiểm tra kiểu đầy đủ rồi bỏ type argument khỏi bytecode. Gần như mọi hạn chế “lạ” của generics đều suy ra từ quyết định này.

1.1. Compiler làm gì với generics

Khi compile, javac làm bốn việc:

  1. Kiểm tra kiểu với đầy đủ thông tin generics.
  2. Thay mỗi type parameter bằng erasure của nó: bound đầu tiên nếu có (<T extends Number> thành Number), không thì Object. List<String> thành List.
  3. Chèn checkcast (lệnh bytecode ép kiểu có kiểm tra) ở những chỗ cần đưa giá trị về kiểu cụ thể.
  4. Sinh bridge method khi cần giữ đa hình (1.3).

Lúc chạy, ArrayList<String> và ArrayList<Integer> là cùng một class:

new ArrayList<String>().getClass() == new ArrayList<Integer>().getClass()   // true

Java chọn erasure để tương thích ngược với code trước Java 5. Cái giá là các hạn chế ở mục 1.2.

Bytecode javap -c sau erasure và vì sao Java không giữ kiểu như C#

Ví dụ String first(List<String> l) { return l.get(0); } sau khi compile, nhìn bằng javap -c:

invokeinterface #7,  2   // InterfaceMethod java/util/List.get:(I)Ljava/lang/Object;
checkcast       #13      // class java/lang/String

List.get trả về Object ở bytecode; cast sang String là do compiler chèn vào.

Vì sao Java chọn erasure thay vì giữ kiểu ở runtime như C#? Generics ra đời ở Java 5 (2004), khi đã có hàng triệu dòng code dùng collection không generic. Erasure cho phép code mới và code cũ, thư viện cũ và thư viện mới chạy chung với nhau mà không phải biên dịch lại, và không cần đổi JVM.

1.2. Hệ quả của erasure

Không làm được Vì sao Cách thay thế
List<int> Erasure thành Object, primitive không phải Object List<Integer> (boxing), hoặc IntStream, int[], thư viện primitive collection
new T() Lúc chạy không biết T là class nào Truyền Supplier<T> hoặc Class<T>
new T[n], new List<String>[n] Mảng cần kiểu phần tử thật lúc runtime Array.newInstance(type, n), toArray(String[]::new), hoặc dùng List
obj instanceof List<String> (với obj là Object) Runtime không phân biệt được List<String> và List<Integer> obj instanceof List<?>, rồi kiểm tra từng phần tử nếu cần
static T field Field static dùng chung cho mọi Box<String>, Box<Integer> Đưa T xuống generic method static
class MyEx<T> extends Exception, catch (T e) catch được quyết định lúc runtime bằng kiểu thật Exception không generic, mang dữ liệu bằng field
Overload f(List<String>) và f(List<Integer>) Hai method cùng erasure f(List) Đặt tên khác nhau
Ngoại lệ của instanceof từ Java 16 và lỗi overload trùng erasure

Từ Java 16, pattern matching cho phép instanceof List<String> ls khi compiler chứng minh được nó an toàn, tức kiểu tĩnh đã là Collection<String> hay List<String>. Với Object thì vẫn lỗi Object cannot be safely cast to List<String>.

1.3. Bridge method

Erasure có thể làm hỏng overriding. Xét:

public final class Name implements Comparable<Name> {
    private final String value;
    public Name(String value) { this.value = value; }

    @Override
    public int compareTo(Name other) { return value.compareTo(other.value); }
}

Sau erasure, interface Comparable có compareTo(Object), còn class có compareTo(Name). Hai chữ ký khác nhau, nên về lý thuyết class chưa override method của interface.

Compiler vá bằng một bridge method (đánh dấu synthetic, tức do compiler tạo): compareTo(Object) cast tham số sang Name rồi gọi compareTo(Name). Hai hệ quả:

  • Gọi qua raw type với sai kiểu, ClassCastException được ném từ bridge, một dòng bạn không hề viết.
  • Method.isBridge() tồn tại vì thế. Framework dùng reflection (Spring, Hibernate, Jackson) phải lọc bridge method để không xử lý một method hai lần.
Bridge method nhìn bằng javap -p và ClassCastException ném từ bridge
$ javap -p Name
public final class Name implements java.lang.Comparable<Name> {
  public int compareTo(Name);
  public int compareTo(java.lang.Object);     // bridge: checkcast Name, rồi gọi compareTo(Name)
}

Gọi qua raw type với sai kiểu:

Comparable raw = new Name("a");
raw.compareTo("x");   // ClassCastException: String cannot be cast to Name (từ bridge method)

1.4. Heap pollution và @SafeVarargs

Heap pollution là khi một biến có kiểu tham số hoá (ví dụ List<String>) trỏ tới object không thực sự có kiểu đó. Compiler cảnh báo unchecked mỗi khi có khả năng này. Lỗi thật chỉ lộ ra sau, ở một cast do compiler chèn.

Nguồn phổ biến nhất là raw type (mục 2) và varargs generic. Varargs được cài đặt bằng mảng, mà không thể tạo mảng T[] thật, nên compiler tạo mảng theo erasure:

static <T> T[] toArray(T... args) { return args; }      // cảnh báo: possible heap pollution

static <T> T[] pickTwo(T a, T b, T c) {
    return toArray(a, b);   // T erase thành Object -> luôn tạo Object[]
}

String[] two = pickTwo("a", "b", "c");
// ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.String;

Bên trong pickTwo, compiler không biết T là gì, nên mảng varargs là Object[]. Mảng đó ra tới chỗ gọi thì bị cast sang String[] và nổ. Vì vậy: không trả mảng varargs generic ra ngoài, không ghi vào nó.

@SafeVarargs là lời hứa của người viết method:

  • Method không ghi gì vào mảng varargs và không để lộ tham chiếu tới mảng ra ngoài. Khi đó cảnh báo ở phía caller biến mất.
  • Chỉ đặt được lên method không thể override: static, final, private (từ Java 9) và constructor.
  • List.of(E...), Set.of(E...), Arrays.asList(T...), Stream.of(T...) đều có @SafeVarargs.
@SafeVarargs dùng đúng và bẫy trả mảng varargs ra ngoài
@SafeVarargs
static <T> List<T> listOf(T... items) {
    return List.of(items);    // chỉ đọc mảng, List.of copy sang cấu trúc riêng
}

1.5. Erasure không xoá hết mọi thứ

Một hiểu lầm phổ biến (tài liệu nhập môn cũng hay viết vậy) là “lúc chạy mọi thông tin generics bị xoá sạch”. Thực tế:

  • Object không biết type argument của nó.
  • Khai báo thì vẫn giữ: chữ ký generic của class, field, method và kiểu cha nằm trong attribute Signature của file .class, đọc được qua reflection.
class Holder {
    Map<String, List<Integer>> data;
}

Field f = Holder.class.getDeclaredField("data");
System.out.println(f.getGenericType());
// java.util.Map<java.lang.String, java.util.List<java.lang.Integer>>

Đây là nền tảng của type token ở phần 4. Spring biết bean nào inject vào Repository<User> cũng nhờ đọc metadata khai báo này.

2. Raw type

Ý chính: raw type là tên generic type viết không kèm type argument (List, Map, Comparable), tồn tại chỉ để tương thích với code trước Java 5. Dùng nó là tắt toàn bộ kiểm tra generic với biến đó.

Raw type còn làm hỏng được một collection đang được tham chiếu bằng kiểu đúng:

List<String> strings = new ArrayList<>();
List raw = strings;          // được phép, không cảnh báo
raw.add(42);                 // cảnh báo unchecked, nhưng vẫn chạy
System.out.println(strings.size());   // 1

String s = strings.get(0);   // ClassCastException ở đây, xa chỗ gây lỗi

Một số chỗ raw type là hợp lệ và không tránh được:

  • Class literal: List.class (không có List<String>.class).
  • instanceof (dù instanceof List<?> đọc rõ ý hơn).
  • Làm việc với thư viện cũ chưa generic.

Khi buộc phải làm việc với code không type-safe:

  • Bật -Xlint:unchecked.
  • Giới hạn @SuppressWarnings("unchecked") ở phạm vi nhỏ nhất: một biến cục bộ, kèm comment vì sao an toàn.
  • Collection nhận dữ liệu từ code không tin cậy: bọc bằng Collections.checkedList(list, String.class) để kiểm tra kiểu ngay lúc add.

3. Reifiable type

Ý chính: một kiểu là reifiable nếu thông tin của nó còn đầy đủ lúc chạy. Mảng, instanceof và cast có kiểm tra chỉ làm việc được với kiểu reifiable.

Reifiable gồm:

  • Kiểu primitive (int) và kiểu không generic (String, Number).
  • Raw type (List).
  • Kiểu tham số hoá chỉ toàn unbounded wildcard (List<?>, Map<?, ?>).
  • Mảng mà kiểu phần tử reifiable (String[], List<?>[]).

Không reifiable: List<String>, T, List<? extends Number>, Map<String, T>.

Khái niệm này gom các quy tắc rời rạc ở trên về một mối:

  • Mảng chỉ tạo được với kiểu phần tử reifiable, vì mảng phải kiểm tra ArrayStoreException lúc chạy: new List<?>[10] được, new List<String>[10] thì không.
  • Cast sang kiểu không reifiable ((List<String>) obj) là unchecked cast.
  • Varargs với kiểu không reifiable sinh cảnh báo heap pollution.

4. Lấy lại kiểu lúc runtime: type token

Ý chính: khi một method thật sự cần kiểu lúc chạy (tạo object, tạo mảng, deserialize JSON), hãy truyền kiểu vào như một giá trị. Có ba cách: Class<T>, Supplier<T> và super type token.

Class token: truyền Class<T>.

static <T> T[] newArray(Class<T> type, int size) {
    @SuppressWarnings("unchecked")   // an toàn: Array.newInstance tạo đúng mảng T[]
    T[] array = (T[]) Array.newInstance(type, size);
    return array;
}

String[] names = newArray(String.class, 3);

Class<T> có type.cast(obj) (cast có kiểm tra) và type.isInstance(obj). JDK dùng mẫu này ở EnumMap(Class<K>), Collections.checkedList(list, Class<E>), ServiceLoader.load(Class<S>).

Factory: thay vì new T(), nhận Supplier<T>. Gọn hơn reflection và cho phép truyền constructor có tham số.

static <T> T create(Supplier<? extends T> factory) { return factory.get(); }

StringBuilder sb = create(StringBuilder::new);
String[] arr = List.of("a", "b").toArray(String[]::new);   // IntFunction<T[]> cũng là một dạng factory

Super type token: Class<T> không biểu diễn được List<User> (chỉ có List.class). Mẹo của Neal Gafter: tạo một anonymous subclass của một class generic trừu tượng. Kiểu cha của anonymous class được ghi vào file .class (mục 1.5), nên đọc lại được. Thư viện thật dùng đúng mẫu này:

// Jackson
List<User> users = objectMapper.readValue(json, new TypeReference<List<User>>() {});

// Spring RestClient / RestTemplate / WebClient
List<User> users = restClient.get().uri("/users")
        .retrieve()
        .body(new ParameterizedTypeReference<List<User>>() {});

// Gson
Type listType = new TypeToken<List<User>>() {}.getType();

Dấu {} ở cuối là bắt buộc: nó tạo anonymous subclass. Bỏ {} thì không compile được (class abstract), nên mẫu này không thể bị dùng sai một cách im lặng.

Tự viết super type token: TypeRef<T> trong mười dòng
public abstract class TypeRef<T> {
    private final Type type;

    protected TypeRef() {
        ParameterizedType superType = (ParameterizedType) getClass().getGenericSuperclass();
        this.type = superType.getActualTypeArguments()[0];
    }

    public Type type() { return type; }
}

Type t = new TypeRef<Map<String, List<Integer>>>() {}.type();
// java.util.Map<java.lang.String, java.util.List<java.lang.Integer>>

Constructor đọc kiểu cha generic của chính anonymous class (getGenericSuperclass()), rồi lấy type argument đầu tiên.

5. Generics với record và sealed interface

Ý chính: sealed interface cộng generic record cho bạn một kiểu tổng (sum type, giá trị thuộc đúng một trong vài dạng cố định) như Result<T>. Compiler kiểm tra switch đã đủ mọi dạng. Record và sealed interface có từ Java 17, record pattern trong switch từ Java 21.

Ví dụ kết quả thành công hoặc thất bại:

public sealed interface Result<T> permits Ok, Err {}
public record Ok<T>(T value) implements Result<T> {}
public record Err<T>(String message) implements Result<T> {}

static String describe(Result<Integer> result) {
    return switch (result) {
        case Ok<Integer>(Integer v) when v > 100 -> "big " + v;
        case Ok(var v) -> "ok " + v;              // Java 21 tự suy ra Ok<Integer>
        case Err(var message) -> "error: " + message;
    };
}

Những điểm đáng chú ý:

  • switch exhaustive (phủ đủ mọi trường hợp): Result là sealed với đúng hai lớp con, nên không cần default. Thêm một lớp con vào permits thì mọi switch thiếu case sẽ lỗi compile, đúng chỗ cần sửa.
  • Record pattern suy ra type argument: case Ok(var v) được hiểu là Ok<Integer>, v có kiểu Integer.

Mẫu này hay gặp trong backend: kết quả validate, kết quả gọi service ngoài, event trong event sourcing (sealed interface OrderEvent), response DTO dạng ApiResponse<T>.

Generic record Pair<A, B>, ghi chú về Err<T> và generics hằng ngày trong Spring

Err<T> không dùng T trong field nào, nhưng vẫn phải có T để là Result<T>. Nếu muốn lỗi cũng có kiểu, dùng Result<T, E> (bài tập 1 mở rộng ý này).

Generic record: một cặp giá trị không cần viết equals/hashCode/toString:

public record Pair<A, B>(A first, B second) {
    public static <A, B> Pair<A, B> of(A first, B second) { return new Pair<>(first, second); }

    public <C> Pair<A, C> withSecond(C newSecond) { return new Pair<>(first, newSecond); }
}

Pair<String, Integer> p = Pair.of("age", 30);
Pair<String, Boolean> q = p.withSecond(true);

Trong Spring bạn dùng generics hằng ngày mà ít để ý: JpaRepository<User, Long> (xem ORM và JPA), ResponseEntity<UserDto>, Optional<T>, Page<T>.

Spring còn inject theo generic type: nếu có Validator<User> và Validator<Order> là hai bean, @Autowired Validator<User> v sẽ nhận đúng bean đầu, nhờ đọc metadata khai báo ở mục 1.5 (xem IoC và Dependency Injection).

Bài tập

Bài 1: Result<T> với map và flatMap

Đề: mở rộng Result<T> sealed ở phần 5 với map, flatMap, orElse, rồi dùng để parse một chuỗi thành số dương và nhân đôi, không dùng exception để báo lỗi.

Lời giải Bài 1: Result<T> với map, flatMap, orElse
sealed interface Result<T> permits Result.Ok, Result.Err {
    record Ok<T>(T value) implements Result<T> {}
    record Err<T>(String error) implements Result<T> {}

    static <T> Result<T> ok(T value) { return new Ok<>(value); }
    static <T> Result<T> err(String error) { return new Err<>(error); }

    default <R> Result<R> map(Function<? super T, ? extends R> f) {
        return switch (this) {
            case Ok<T>(T v) -> new Ok<>(f.apply(v));
            case Err<T>(String e) -> new Err<>(e);
        };
    }

    default <R> Result<R> flatMap(Function<? super T, ? extends Result<? extends R>> f) {
        return switch (this) {
            case Ok<T>(T v) -> narrow(f.apply(v));
            case Err<T>(String e) -> new Err<>(e);
        };
    }

    default T orElse(T fallback) {
        return this instanceof Ok<T>(T v) ? v : fallback;
    }

    // An toàn vì Result bất biến: chỉ đọc T ra, không bao giờ ghi T vào
    @SuppressWarnings("unchecked")
    private static <R> Result<R> narrow(Result<? extends R> r) { return (Result<R>) r; }
}

static Result<Integer> parse(String s) {
    try { return Result.ok(Integer.parseInt(s)); }
    catch (NumberFormatException e) { return Result.err("not a number: " + s); }
}
static Result<Integer> positive(int n) {
    return n > 0 ? Result.ok(n) : Result.err("not positive: " + n);
}

parse("42").flatMap(Main::positive).map(n -> n * 2);    // Ok[value=84]
parse("-3").flatMap(Main::positive).map(n -> n * 2);    // Err[error=not positive: -3]
parse("abc").flatMap(Main::positive).map(n -> n * 2);   // Err[error=not a number: abc]
Result<Number> widened = parse("5").flatMap(Main::positive);   // nhờ ? extends R

Giải thích chữ ký:

  • Function<? super T, ? extends R> là PECS (hàm nhận T, trả ra R).
  • flatMap nhận hàm trả Result<? extends R> để một hàm trả Result<Integer> dùng được khi cần Result<Number>.
  • Cast trong narrow là unchecked nhưng an toàn vì Result là immutable và chỉ “sản xuất” T. Đây chính là lập luận mà các ngôn ngữ có declaration-site variance (Kotlin out T) để compiler tự làm.

Bài 2: Container dị kiểu type-safe

Đề: viết một Context lưu nhiều giá trị khác kiểu (số lần retry là Integer, user là String…) mà lấy ra không cần cast và không thể lấy sai kiểu.

Ý tưởng (từ Effective Java, “typesafe heterogeneous container”): đưa type parameter lên key thay vì lên container.

Lời giải Bài 2: Key<T> và Context
final class Key<T> {
    final String name;
    final Class<T> type;

    private Key(String name, Class<T> type) { this.name = name; this.type = type; }

    static <T> Key<T> of(String name, Class<T> type) { return new Key<>(name, type); }
}

final class Context {
    private final Map<Key<?>, Object> values = new HashMap<>();

    <T> void put(Key<T> key, T value) {
        values.put(key, key.type.cast(value));   // cast có kiểm tra, chặn raw type lách luật
    }

    <T> Optional<T> get(Key<T> key) {
        return Optional.ofNullable(key.type.cast(values.get(key)));
    }
}

Key<Integer> RETRIES = Key.of("retries", Integer.class);
Key<String> USER = Key.of("user", String.class);

Context ctx = new Context();
ctx.put(RETRIES, 3);
ctx.put(USER, "vinh");
int retries = ctx.get(RETRIES).orElse(0);   // không cast
// ctx.put(RETRIES, "three");               // lỗi compile

Map<Key<?>, Object> bên trong không type-safe, nhưng API public đảm bảo mỗi giá trị luôn khớp kiểu key của nó, và Class.cast kiểm tra lại lúc chạy. Spring dùng ý tưởng tương tự ở AttributeAccessor, Netty ở AttributeKey<T>, Reactor ở Context.

Ghi nhớ

  • Giải thích được bốn việc compiler làm với generics và vì sao Java chọn erasure.
  • Kể được ít nhất năm thứ erasure cấm, kèm cách thay thế cho từng thứ.
  • Giải thích được vì sao ClassCastException có thể ném từ một dòng bạn không viết (bridge method, cast do compiler chèn).
  • Biết khi nào dùng Class<T>, Supplier<T>, khi nào phải dùng TypeReference, và vì sao cần {}.
  • Biết khi nào được gắn @SafeVarargs, và khi nào chọn Result<T> sealed thay cho exception.

Câu hỏi phỏng vấn

Junior

Vì sao không viết được List<int>?

Do type erasure: type parameter bị thay bằng Object (hoặc bound), mà int không phải Object.

Phải dùng wrapper List<Integer> (có chi phí boxing, mỗi phần tử là một object trên heap). Khi hiệu năng quan trọng thì dùng int[], IntStream hoặc thư viện primitive collection.

Mid

Type erasure là gì và gây ra những hạn chế nào?

Compiler kiểm tra kiểu đầy đủ rồi xoá type argument: thay T bằng bound (hoặc Object), chèn cast, sinh bridge method.

Hệ quả:

  • Không List<int>, không new T(), không new T[].
  • Không instanceof List<String> trên Object, không field static T, không generic exception.
  • Không overload hai method chỉ khác type argument.
  • ArrayList<String>.class == ArrayList<Integer>.class.

Lý do chọn erasure: tương thích ngược với code trước Java 5 mà không phải đổi JVM.

Bridge method là gì, khi nào compiler sinh ra?

Là method synthetic compiler thêm vào để giữ đa hình sau erasure.

Ví dụ class Name implements Comparable<Name> có compareTo(Name), nhưng interface sau erase là compareTo(Object). Compiler sinh compareTo(Object) cast sang Name rồi gọi bản thật. Bridge cũng được sinh khi override với kiểu trả về covariant.

Gọi qua raw type với sai kiểu sẽ ném ClassCastException từ bridge. Framework dùng reflection phải lọc Method.isBridge().

Làm sao tạo instance hoặc mảng của T khi new T() không được phép?

Truyền kiểu vào như một giá trị.

  • Object: Supplier<T> (ví dụ create(StringBuilder::new)), hoặc Class<T> với type.getDeclaredConstructor().newInstance() nếu cần reflection.
  • Mảng: Array.newInstance(type, n) hoặc IntFunction<T[]> (toArray(String[]::new)).

Supplier được ưu tiên vì không dùng reflection và kiểm tra được lúc compile.

Raw type nguy hiểm thế nào? Khi nào buộc phải dùng?

Raw type (List không có <...>) tắt toàn bộ kiểm tra generic với biến đó, nên lỗi kiểu nổ muộn và xa chỗ gây ra.

Gán List<String> cho một biến List rồi add(42) chỉ sinh cảnh báo unchecked. ClassCastException nổ ở chỗ đọc, có khi ở module khác.

Chỉ dùng ở chỗ không tránh được: class literal (List.class), thư viện trước Java 5. Khi phải làm việc với code không type-safe: bật -Xlint:unchecked, giới hạn @SuppressWarnings ở phạm vi nhỏ nhất, bọc bằng Collections.checkedList để lỗi ném ngay ở chỗ add sai.

Senior

Jackson làm sao biết cần deserialize thành List<User> khi generics đã bị erase?

Nhờ super type token: new TypeReference<List<User>>() {} tạo một anonymous subclass, và kiểu cha generic của nó vẫn nằm trong file .class.

Kiểu cha TypeReference<List<User>> được lưu trong attribute Signature của class đó, đọc bằng getClass().getGenericSuperclass() ra một ParameterizedType đầy đủ. Erasure chỉ xoá type argument khỏi object, không xoá khỏi khai báo.

Spring dùng cùng kỹ thuật với ParameterizedTypeReference và ResolvableType. Nếu truyền List.class, Jackson chỉ tạo được list của LinkedHashMap.

Heap pollution là gì? @SafeVarargs dùng khi nào?

Heap pollution là khi biến có kiểu tham số hoá trỏ tới object không đúng kiểu đó; @SafeVarargs chỉ dùng khi method không ghi vào mảng varargs và không để lộ nó.

Heap pollution đến từ raw type hoặc unchecked cast; lỗi lộ ra muộn ở cast compiler chèn. Varargs generic là nguồn phổ biến vì mảng varargs được tạo theo erasure (Object[]): trả mảng đó ra ngoài sẽ gây ClassCastException ở caller.

@SafeVarargs chỉ đặt được trên method static, final, private và constructor. Gắn sai chỉ giấu cảnh báo.

Từ vựng tiếng Anh

Term Phát âm Nghĩa Ví dụ câu trong phỏng vấn
type erasure /taɪp ɪˈreɪʒər/ xoá kiểu “Because of type erasure, both lists share the same runtime class.”
reifiable /ˈriːɪfaɪəbəl/ còn đủ thông tin kiểu lúc chạy “You can only create arrays of reifiable types.”
raw type /rɔː taɪp/ kiểu thô, không có type argument “Raw types exist only for backward compatibility.”
heap pollution /hiːp pəˈluːʃən/ ô nhiễm heap “Returning a generic varargs array causes heap pollution.”
bridge method /brɪdʒ ˈmɛθəd/ method cầu nối do compiler sinh “The compiler generates a bridge method to preserve polymorphism.”
unchecked warning /ʌnˈtʃɛkt ˈwɔːrnɪŋ/ cảnh báo không kiểm tra được “I treat unchecked warnings as bugs unless I can prove the cast is safe.”
type token /taɪp ˈtoʊkən/ giá trị đại diện cho một kiểu “We pass a type token because the method needs the type at runtime.”
backward compatibility /ˈbækwərd kəmˌpætəˈbɪləti/ tương thích ngược “Erasure was chosen for backward compatibility with pre-Java 5 code.”
exhaustive /ɪɡˈzɔːstɪv/ bao phủ đủ mọi trường hợp “With a sealed interface, the switch is exhaustive without a default branch.”

Ghi chép dựa trên tài liệu Java Core của Hỏi Dân IT và kiến thức tự tìm hiểu, viết lại theo cách hiểu của mình.