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 kết thúc ở invariance: List<Integer> không phải List<Number>, an toàn nhưng cứng nhắc. Bài này nói về wildcard (<?>, <? extends T>, <? super T>) và quy tắc PECS, công cụ để nới lỏng điều đó mà vẫn an toàn. Đọc xong, bạn chọn đúng wildcard cho từng tham số và đọc nhanh chữ ký JDK như Collections.copy, Stream.map, List.sort. Nên đọc phần 1 trước; vì sao generics không kiểm tra được lúc runtime nằm ở phần 3.
1. Wildcard và quy tắc PECS
Ý chính: wildcard ? nghĩa là “một kiểu nào đó mà tôi không biết chính xác”. Chọn loại nào tuỳ vào việc method đọc từ tham số (extends) hay ghi vào tham số (super).
Invariance nghĩa là kiểu generic không kế thừa theo type argument. Hệ quả: hàm tính tổng nhận List<Number> sẽ từ chối List<Integer>, dù đọc số từ List<Integer> hoàn toàn an toàn. Wildcard sinh ra để gỡ chỗ cứng này.
1.1. Unbounded wildcard <?>
Ý chính: List<?> là cách viết type-safe của “list gì cũng được”. Dùng khi code không phụ thuộc kiểu phần tử.
Các thao tác dùng được: size(), isEmpty(), clear(), remove(...), và đọc phần tử ra dưới dạng Object.
static void printAll(Collection<?> items) {
for (Object item : items) System.out.println(item);
}
Không thể add vào List<?> (trừ null), vì compiler không biết kiểu thật để kiểm tra. Ba thứ hay bị nhầm với nhau:
List<Object> |
List<?> |
List (raw) |
|
|---|---|---|---|
Nhận List<String> làm đối số |
Không | Có | Có (kèm cảnh báo khi dùng) |
add("x") |
Được, list chứa mọi thứ | Không (chỉ add(null)) |
Được, kèm cảnh báo unchecked, có thể làm hỏng list |
| Đọc phần tử | Object |
Object |
Object |
| Type-safe | Có | Có | Không |
Raw List (list viết thiếu type argument) tắt luôn việc kiểm tra kiểu, nên không thay được List<?>.
Khi thật sự cần ghi vào một List<?> (ví dụ đổi chỗ hai phần tử), dùng wildcard capture helper. Đó là một method generic private “bắt” kiểu chưa biết thành một T có tên:
public static void swapFirstTwo(List<?> list) {
swapHelper(list); // compiler capture ? thành T
}
private static <T> void swapHelper(List<T> list) {
T first = list.get(0);
list.set(0, list.get(1));
list.set(1, first);
}
Chữ ký public vẫn gọn (List<?>), phần cài đặt vẫn type-safe. Collections.swap và Collections.reverse trong JDK dùng chữ ký List<?> như vậy.
Bảng so sánh List<?> với type parameter T
So sánh theo việc có thể làm gì với list:
List<?> |
<T> ... List<T> |
|
|---|---|---|
| Ý nghĩa | Một kiểu cụ thể nào đó, không biết là gì | Một kiểu cụ thể do caller quyết định, có tên T |
| Khai báo | Không cần khai báo gì thêm | Phải khai báo <T> trước kiểu trả về (hoặc trên class) |
| Dùng để định nghĩa class generic | Không (class Box<?> không hợp lệ) |
Có |
add/set phần tử |
Không (trừ null) |
Được, với giá trị kiểu T |
remove, clear |
Được | Được |
| Đọc phần tử | Ra Object |
Ra T, không cần cast |
| Hợp với | Method chỉ đọc hoặc xoá, không quan tâm kiểu | Method cần ghi, trả về, hoặc liên kết kiểu giữa nhiều tham số |
1.2. Upper bounded wildcard <? extends T>
Ý chính: ? extends T cho đọc phần tử ra dưới dạng T, nhưng không ghi được (trừ null).
List<? extends Number> nhận List<Number>, List<Integer>, List<Double>…
static double sum(Collection<? extends Number> numbers) {
double total = 0;
for (Number n : numbers) total += n.doubleValue();
return total;
}
sum(List.of(1, 2, 3)); // List<Integer>: OK
sum(Set.of(1.5, 2.5)); // Set<Double>: OK
void broken(List<? extends Number> list) {
// list.add(1); // lỗi: list có thể đang là List<Double>
}
Lý do không ghi được: compiler chỉ biết “đây là list của một kiểu con nào đó của Number”. Nếu kiểu thật là List<Double> thì thêm Integer sẽ phá list. Không có giá trị nào (ngoài null) chắc chắn hợp lệ cho mọi kiểu con.
1.3. Lower bounded wildcard <? super T>
Ý chính: ? super T cho ghi T (và lớp con của nó) vào, nhưng khi đọc chỉ biết chắc phần tử là Object.
List<? super Integer> nhận List<Integer>, List<Number>, List<Object>.
static void fillWithIndexes(List<? super Integer> out, int count) {
for (int i = 0; i < count; i++) out.add(i); // Integer luôn hợp lệ
}
List<Object> sink = new ArrayList<>();
fillWithIndexes(sink, 3); // [0, 1, 2]
void readBack(List<? super Integer> list) {
Object o = list.get(0); // OK
// Integer i = list.get(0); // lỗi: có thể là List<Object>
}
1.4. PECS: Producer Extends, Consumer Super
Ý chính: tham số bạn đọc T ra thì dùng ? extends T, tham số bạn ghi T vào thì dùng ? super T. Vừa đọc vừa ghi thì dùng đúng T.
Tên quy tắc do Joshua Bloch đặt trong Effective Java:
- Tham số cung cấp (produce) giá trị
Tcho bạn đọc →? extends T. - Tham số nhận (consume) giá trị
Tbạn ghi vào →? super T. - Vừa đọc vừa ghi →
T, không wildcard.
Ví dụ kinh điển là hàm copy, chữ ký giống hệt Collections.copy trong JDK:
// JDK: public static <T> void copy(List<? super T> dest, List<? extends T> src)
static <T> void copyInto(Collection<? super T> dest, Collection<? extends T> src) {
for (T item : src) dest.add(item); // đọc từ producer, ghi vào consumer
}
List<Integer> ints = List.of(1, 2, 3);
List<Number> numbers = new ArrayList<>();
copyInto(numbers, ints); // T = Integer: src là List<Integer>, dest là List<Number>
Nếu chữ ký là copy(List<T> dest, List<T> src) thì lời gọi trên không compile được: không có T nào vừa bằng Number vừa bằng Integer.
PECS xuất hiện khắp JDK. Nhận ra nó giúp đọc chữ ký API nhanh hơn nhiều:
| API | Chữ ký | Đọc theo PECS |
|---|---|---|
Collection.addAll |
addAll(Collection<? extends E> c) |
c là producer |
Collections.addAll |
<T> addAll(Collection<? super T> c, T... elements) |
c là consumer |
List.sort |
sort(Comparator<? super E> c) |
comparator “tiêu thụ” phần tử để so sánh |
Stream.map |
<R> map(Function<? super T, ? extends R> mapper) |
input là consumer, output là producer |
Map.computeIfAbsent |
computeIfAbsent(K key, Function<? super K, ? extends V> fn) |
tương tự |
Nhờ Comparator<? super E>, một Comparator<Object> (so theo toString) hay Comparator<Number> dùng được để sort List<Integer>.
Sơ đồ quan hệ cha con khi có wildcard (mũi tên chỉ từ con lên cha):
flowchart BT
LI["List#lt;Integer#gt;"] --> EI["List#lt;? extends Integer#gt;"]
EI --> EN["List#lt;? extends Number#gt;"]
LN["List#lt;Number#gt;"] --> EN
EN --> ANY["List#lt;?#gt;"]
LN --> SN["List#lt;? super Number#gt;"]
SN --> SI["List#lt;? super Integer#gt;"]
LI --> SI
SI --> ANY
List<Integer> và List<Number> không nối trực tiếp với nhau, nhưng cả hai cùng là con của List<? extends Number>.
Hai chi tiết dễ vấp: Collections.copy và target typing của List.of
Bài tập
Bài 1: Lab 10: kho hàng với InventoryItem<T>
Đề (diễn đạt lại):
- Class
InventoryItem<T>có mã (số hoặc SKU chuỗi), tên, giá, constructor và getter/setter. - Class tiện ích
InventoryUtilscó generic methodprintItemInfoin một item theo dạngID: ..., Name: ..., Price: ..., và generic methodcalculateTotalPricetính tổng giá của một list item. - Trong
main: tạo một list chứa cả item mã số lẫn item mã chuỗi, in từng item rồi in tổng tiền. Ví dụ hai item 1500 và 1200 thì inTotal price: 2700.0.
Cái bẫy trong đề: nếu viết static <T> double calculateTotalPrice(List<InventoryItem<T>> items) thì không truyền được list chứa cả InventoryItem<Integer> lẫn InventoryItem<String>, vì T phải là một kiểu duy nhất. Hàm tính tổng không quan tâm kiểu mã, nên dùng wildcard.
Lời giải Bài 1: code đầy đủ, output và giải thích
Chạy được bằng java Main.java:
import java.math.BigDecimal;
import java.util.*;
public class Main {
public static void main(String[] args) {
List<InventoryItem<?>> items = List.of(
new InventoryItem<>(1001, "Laptop Dell", new BigDecimal("1500.0")),
new InventoryItem<>("SKU12345", "iPhone 15", new BigDecimal("1200.0")));
items.forEach(InventoryUtils::printItemInfo); // capture: mỗi phần tử có T riêng
System.out.println("Total price: " + InventoryUtils.calculateTotalPrice(items));
List<InventoryItem<Integer>> laptops = List.of(
new InventoryItem<>(1, "ThinkPad", new BigDecimal("1100.50")),
new InventoryItem<>(2, "MacBook", new BigDecimal("1999.99")));
System.out.println("Laptops total: " + InventoryUtils.calculateTotalPrice(laptops));
System.out.println("Find 2: " + InventoryUtils.findById(laptops, 2).map(InventoryItem::getName).orElse("none"));
// InventoryUtils.findById(laptops, "2"); // lỗi compile: T không thể vừa là Integer vừa là String
}
}
final class InventoryItem<T> {
private final T id; // mã là định danh: không cho đổi sau khi tạo
private String name;
private BigDecimal price;
InventoryItem(T id, String name, BigDecimal price) {
this.id = Objects.requireNonNull(id, "id");
setName(name);
setPrice(price);
}
T getId() { return id; }
String getName() { return name; }
BigDecimal getPrice() { return price; }
void setName(String name) { this.name = Objects.requireNonNull(name, "name"); }
void setPrice(BigDecimal price) {
if (price.signum() < 0) throw new IllegalArgumentException("price must be >= 0");
this.price = price;
}
}
final class InventoryUtils {
private InventoryUtils() {}
// Đúng chữ ký đề yêu cầu: generic method, T suy ra từ đối số
static <T> void printItemInfo(InventoryItem<T> item) {
System.out.printf("ID: %s, Name: %s, Price: %s%n", item.getId(), item.getName(), item.getPrice());
}
// producer, không quan tâm kiểu id -> ? extends InventoryItem<?>
static BigDecimal calculateTotalPrice(Collection<? extends InventoryItem<?>> items) {
BigDecimal total = BigDecimal.ZERO;
for (InventoryItem<?> item : items) total = total.add(item.getPrice());
return total;
}
// ở đây T thật sự liên kết hai tham số: id cần tìm phải cùng kiểu với id của item
static <T> Optional<InventoryItem<T>> findById(Collection<InventoryItem<T>> items, T id) {
for (InventoryItem<T> item : items) {
if (item.getId().equals(id)) return Optional.of(item);
}
return Optional.empty();
}
}
Output khi chạy với JDK 21:
ID: 1001, Name: Laptop Dell, Price: 1500.0
ID: SKU12345, Name: iPhone 15, Price: 1200.0
Total price: 2700.0
Laptops total: 3100.49
Find 2: MacBook
Giải thích:
calculateTotalPricenhận được cảList<InventoryItem<?>>(list trộn) lẫnList<InventoryItem<Integer>>(list đồng nhất):? extends InventoryItem<?>là producer (chỉ đọc ra) và không quan tâm kiểu mã.printItemInfogiữ đúng chữ ký generic mà đề yêu cầu. Lời gọiitems.forEach(InventoryUtils::printItemInfo)vẫn compile dù phần tử làInventoryItem<?>, vì compiler “capture” kiểu chưa biết thành mộtTcho từng lần gọi. VìTchỉ xuất hiện một lần trong chữ ký, viếtprintItemInfo(InventoryItem<?> item)là tương đương và gọn hơn.findByIdlà chỗTthật sự cần: nó buộc kiểu id cần tìm phải trùng kiểu id của item, nênfindById(laptops, "2")bị chặn ngay lúc compile.- Giá dùng
BigDecimalthay vìdoublenhư đề để tổng tiền không bị sai số làm tròn;new BigDecimal("1500.0")in ra đúng1500.0như output mẫu.
Một senior sẽ cải thiện thêm:
- Bỏ setter của
pricevàname: item bất biến, đổi giá thì tạo bản mới hoặc ghi lịch sử giá. - Dùng
record InventoryItem<T>(T id, String name, BigDecimal price)với compact constructor để validate. - Cân nhắc lại việc cho mã có hai kiểu: trong hệ thống thật, một kiểu
Skuriêng (record bọcString) rõ nghĩa hơn genericT.
Bài 2: Cache LRU generic
Đề: viết LruCache<K, V> giới hạn số phần tử, loại phần tử lâu không dùng nhất khi đầy, có getOrCompute(key, loader). Mục đích chính là luyện chữ ký PECS cho loader và putAll.
Lời giải Bài 2: LruCache trên LinkedHashMap
final class LruCache<K, V> {
private final int capacity;
private final LinkedHashMap<K, V> map;
LruCache(int capacity) {
if (capacity <= 0) throw new IllegalArgumentException("capacity must be > 0");
this.capacity = capacity;
// accessOrder = true: mỗi lần get/put, phần tử được đưa về cuối
this.map = new LinkedHashMap<>(16, 0.75f, true) {
@Override
protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
return size() > LruCache.this.capacity;
}
};
}
Optional<V> get(K key) { return Optional.ofNullable(map.get(key)); }
void put(K key, V value) { map.put(key, value); }
V getOrCompute(K key, Function<? super K, ? extends V> loader) {
return map.computeIfAbsent(key, loader);
}
void putAll(Map<? extends K, ? extends V> other) { map.putAll(other); }
}
LruCache<String, Integer> cache = new LruCache<>(2);
cache.getOrCompute("a", String::length);
cache.getOrCompute("bb", String::length);
cache.get("a"); // "a" vừa được dùng
cache.getOrCompute("ccc", String::length); // đầy -> loại "bb"
Function<Object, Integer> hash = Object::hashCode;
cache.getOrCompute("d", hash); // Function<Object, Integer> dùng được nhờ ? super K
Lưu ý: cache này không thread-safe. Trong production dùng Caffeine (hoặc Collections.synchronizedMap nếu tải nhẹ); đừng tự viết cache đồng thời.
Bài 3: Sửa chữ ký sai
Đề: các chữ ký sau compile được nhưng quá cứng. Sửa để chúng nhận được mọi đối số hợp lý.
// Trước
static double average(List<Number> nums)
static <T> void addAll(List<T> target, List<T> source)
static <T> T maxBy(List<T> items, Comparator<T> cmp)
static <T> void forEachMatching(List<T> src, Predicate<T> p, Consumer<T> action)
Lời giải Bài 3: bốn chữ ký sau khi áp PECS
static double average(Collection<? extends Number> nums) {
if (nums.isEmpty()) throw new IllegalArgumentException("empty");
double sum = 0;
for (Number n : nums) sum += n.doubleValue();
return sum / nums.size();
}
static <T> void addAll(Collection<? super T> target, Collection<? extends T> source) {
for (T t : source) target.add(t);
}
static <T> T maxBy(Collection<? extends T> items, Comparator<? super T> cmp) {
Iterator<? extends T> it = items.iterator();
if (!it.hasNext()) throw new NoSuchElementException();
T best = it.next();
while (it.hasNext()) {
T x = it.next();
if (cmp.compare(x, best) > 0) best = x;
}
return best;
}
static <T> void forEachMatching(Iterable<? extends T> src,
Predicate<? super T> p,
Consumer<? super T> action) {
for (T t : src) if (p.test(t)) action.accept(t);
}
average(List.of(1, 2, 3, 4)); // List<Integer>
average(Set.of(1.5, 2.5)); // Set<Double>
Comparator<Object> byString = Comparator.comparing(Object::toString);
Integer m = maxBy(List.of(3, 12, 9), byString); // 9 (so theo chuỗi)
forEachMatching(List.of(1, 2, 3, 4),
(Number n) -> n.intValue() % 2 == 0,
(Object o) -> System.out.println("even " + o));
Ngoài wildcard, chữ ký mới còn nới List thành Collection/Iterable: chỉ yêu cầu đúng khả năng mà method dùng tới.
Ghi nhớ
- Giải thích được vì sao không
addđược vàoList<? extends Number>và không đọc raIntegerđược từList<? super Integer>. - Phân biệt được
List<?>,List<Object>và rawList. - Đọc được chữ ký
Collections.copy,List.sort,Stream.maptheo PECS. - Biết khi nào dùng wildcard, khi nào dùng type parameter, và vì sao không trả về kiểu có wildcard.
- Viết được chữ ký hàm nhận list trộn
InventoryItem<Integer>vàInventoryItem<String>.
Câu hỏi phỏng vấn
Junior
List<?>, List<Object> và List khác nhau thế nào?
List<Object> chứa mọi thứ nhưng không nhận List<String>; List<?> nhận mọi list và vẫn type-safe; raw List tắt kiểm tra kiểu.
List<Object>: không nhậnList<String>làm đối số vì invariance.List<?>: list của một kiểu chưa biết, đọc raObject, không add được (trừnull).Listraw: add gì cũng được và có thể làm hỏng list, chỉ để tương thích code cũ.
Vì sao không add được Integer vào List<? extends Number>?
Vì list đó có thể đang là List<Double>, và thêm Integer vào sẽ phá list.
Compiler chỉ biết “list của một kiểu con nào đó của Number”: có thể là List<Double>, List<Integer> hay List<Number>. Không có giá trị nào (ngoài null) chắc chắn hợp lệ với mọi kiểu con. Vì vậy ? extends chỉ để đọc (ra Number); muốn ghi thì dùng ? super Integer.
Mid
PECS là gì? Cho ví dụ trong JDK.
Producer Extends, Consumer Super: tham số mà method đọc T ra thì dùng ? extends T, tham số mà method ghi T vào thì dùng ? super T. Vừa đọc vừa ghi thì dùng T.
Ví dụ: Collections.copy(List<? super T> dest, List<? extends T> src), Collection.addAll(Collection<? extends E>), List.sort(Comparator<? super E>), Stream.map(Function<? super T, ? extends R>).
Viết chữ ký cho hàm tính tổng giá của một list chứa cả InventoryItem<Integer> lẫn InventoryItem<String>.
static BigDecimal total(Collection<? extends InventoryItem<?>> items).
Chữ ký <T> total(List<InventoryItem<T>>) sai vì T phải là một kiểu duy nhất cho cả list, nên list trộn không truyền vào được. InventoryItem<?> nói “item với mã kiểu gì cũng được”, ? extends cho phép truyền cả List<InventoryItem<Integer>>. Method chỉ đọc giá nên đây là producer.
Wildcard capture là gì? Khi nào cần helper method?
Capture là việc compiler đặt một tên tạm cho kiểu chưa biết của List<?>. Cần helper khi phải ghi lại vào list đó.
Tên tạm hiện trong lỗi dạng CAP#1. Bạn không viết được tên đó, nên không thể set phần tử vừa đọc ra trở lại list. Cách giải là gọi một private generic method <T> void helper(List<T> list): compiler suy ra T = kiểu đã capture, và bên trong helper đọc ghi bình thường. Nhờ vậy chữ ký public vẫn là List<?> gọn gàng, như Collections.swap và Collections.reverse.
Vì sao List.sort nhận Comparator<? super E> chứ không phải Comparator<E>?
Vì comparator tiêu thụ phần tử (nhận vào để so sánh), nên theo PECS là ? super E.
Nhờ đó một Comparator<Number> hay Comparator<Object> dùng được để sort List<Integer>, và một comparator viết cho lớp cha (Comparator<Employee>) dùng được cho list lớp con (List<Manager>). Với Comparator<E> thì phải viết lại comparator cho từng kiểu con.
Senior
Khi nào dùng wildcard, khi nào dùng type parameter trong chữ ký method?
Type parameter chỉ xuất hiện một lần → wildcard. Cần liên kết nhiều vị trí hoặc cần ghi phần tử → type parameter.
- Wildcard gọn và rõ ý hơn khi không quan tâm kiểu.
- “Liên kết” nghĩa là input và output cùng kiểu, hoặc hai tham số cùng kiểu.
- Áp PECS cho từng tham số.
- Không trả về kiểu có wildcard vì ép caller mang theo nó.
- Khi chữ ký public dùng
List<?>mà cài đặt cần ghi, dùng private helper<T>(wildcard capture).
Từ vựng tiếng Anh
| Term | Phát âm | Nghĩa | Ví dụ câu trong phỏng vấn |
|---|---|---|---|
| wildcard | /ˈwaɪldkɛərd/ | ký tự đại diện ? |
“A wildcard says I don’t care about the exact element type.” |
| producer / consumer | /prəˈduːsər/ /kənˈsuːmər/ | bên cung cấp / bên tiêu thụ | “The source is a producer, so it takes ? extends T.” |
| invariant | /ɪnˈvɛəriənt/ | bất biến (không kế thừa theo type argument) | “Generics are invariant, so a list of integers isn’t a list of numbers.” |
| upper bound | /ˈʌpər baʊnd/ | giới hạn trên (? extends T) |
“An upper-bounded wildcard lets me read elements as T.” |
| lower bound | /ˈloʊər baʊnd/ | giới hạn dưới (? super T) |
“With a lower bound I can safely add a T to the list.” |
| unbounded wildcard | /ʌnˈbaʊndɪd/ | wildcard không giới hạn (?) |
“List<?> is the type-safe way to say any list.” |
| wildcard capture | /ˈwaɪldkɛərd ˈkæptʃər/ | compiler đặt tên tạm cho ? |
“A private helper uses wildcard capture so the public signature can stay List<?>.” |
| method signature | /ˈmɛθəd ˈsɪɡnətʃər/ | chữ ký method | “Wildcards belong in parameter types, not in the return type of the signature.” |
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.