Cả bài trong một trang: ý chính, sơ đồ, điểm phỏng vấn.
Lambda và Stream API: functional interface, pipeline lười, Collectors và các bẫy
1Functional interface
Interface có đúng một abstract method. Lambda và method reference (String::length) chỉ là cách viết gọn một instance của nó.
Interface
Chữ ký
Dùng cho
Function<T, R>
R apply(T)
map
Predicate<T>
boolean test(T)
filter
Consumer<T>
void accept(T)
forEach
Supplier<T>
T get()
orElseGet, factory
2Pipeline lười
Thao tác trung gian chỉ mô tả việc; thao tác kết thúc mới kéo dữ liệu qua. Phần tử đi từng cái một qua cả chuỗi, nên findFirst dừng được sớm.
flowchart TD
S["Nguồn: a, bb, ccc, dddd"] --> F["filter: a bị loại, bb qua"]
F --> M["map: BB"]
M --> T["findFirst: dừng ngay"]
T -.-> X["ccc, dddd không bao giờ được đọc"]
3Collectors hay dùng
groupingBy chia theo key, nhận thêm collector để gộp từng nhóm. toMap gặp key trùng thì ném IllegalStateException, nên truyền hàm merge.
// doanh thu theo khách, map có thứ tự
orders.stream().collect(groupingBy(
Order::customer, TreeMap::new,
summingLong(Order::amount)));
// key trùng: giữ đơn lớn nhất
orders.stream().collect(toMap(
Order::customer, Order::amount, Math::max));
4Optional dùng đúng
Optional là kiểu trả về cho "có thể không có kết quả". Không dùng làm field, tham số hay phần tử collection.
orElse(x) luôn tính x; orElseGet chỉ tính khi rỗng
Thiếu là lỗi nghiệp vụ: orElseThrow(...)
isPresent() + get() chỉ là null-check dài hơn
Collection rỗng tốt hơn Optional<List<T>>
5Cái giá của boxing
Stream<Integer> chứa object, mỗi phép tính có thể tạo object mới. IntStream, LongStream làm việc thẳng trên primitive. Đo thô 10 triệu số, JDK 21:
Cách viết
Median
Vòng for trên int[]
~21 ms
IntStream
~30 ms
Stream<Long> + reduce
~73 ms
IntStream parallel, 10 nhân
~6 ms
6Parallel stream
parallel() chạy trên ForkJoinPool.commonPool() dùng chung cả JVM. Chỉ lời khi dữ liệu lớn, việc tốn CPU, không side effect, không I/O.
flatMap biến mỗi phần tử thành stream rồi trải phẳng.
Stream chậm hơn for không?
Chút ít ở vòng cực nóng; boxing mới là chênh lớn.
Khi nào không dùng parallel?
Trong request handler, có I/O, nguồn chia kém.
Xong phần tự kiểm tra, bài này đã được đánh dấu đã học ✓
⚠️ Lỗi thường gặp
Đặt logic nghiệp vụ trong peek: count() có thể bỏ qua cả pipeline.
Bắt checked exception trong lambda rồi return null, lỗi biến mất.
Dùng toMap không có hàm merge, test qua, production nổ khi trùng key.
Stream API xuất hiện trong gần như mọi service Java, và cũng là chỗ sinh ra nhiều bug khó thấy: toMap nổ vì trùng key, parallelStream làm hỏng danh sách, peek không chạy. Đọc xong, bạn đọc được một pipeline như JVM chạy nó, chọn đúng collector, và biết khi nào vòng for tốt hơn. Phần cơ bản về lambda (this, effectively final, so với anonymous class) đã có ở Nested class và lambda, bài này không lặp lại.
Sơ đồ tóm tắt:
flowchart LR
SRC["Nguồn: list, array, Stream.of"] --> MID["Trung gian (lười): filter, map, flatMap, sorted"]
MID --> TERM["Kết thúc: collect, reduce, findFirst"]
TERM --> RES["Kết quả"]
MID -.->|"thiếu terminal"| NONE["Không chạy gì"]
TERM -.->|"dừng sớm"| SC["findFirst, anyMatch, limit"]
TERM --> COL["Collectors: groupingBy, toMap + merge"]
MID -.->|"bẫy"| SE["Side effect, peek, dùng lại stream"]
1. Functional interface: hợp đồng một method
Ý chính: functional interface là interface có đúng một abstract method (có thể thêm default và static tuỳ ý). Bất kỳ lambda nào khớp chữ ký của method đó đều là một instance hợp lệ.
@FunctionalInterface không bắt buộc nhưng nên ghi: compiler chặn ai đó thêm abstract method thứ hai. java.util.function có sẵn đủ cho hầu hết trường hợp:
Interface
Chữ ký
Dùng khi
Function<T, R>
R apply(T)
Biến đổi (map)
Predicate<T>
boolean test(T)
Lọc (filter), có and, or, negate, Predicate.not
Consumer<T>
void accept(T)
Làm gì đó với giá trị (forEach)
Supplier<T>
T get()
Tạo giá trị lười (orElseGet, factory)
UnaryOperator<T> / BinaryOperator<T>
T apply(T) / T apply(T, T)
Cùng kiểu vào ra; reduce dùng BinaryOperator
BiFunction<T, U, R>
R apply(T, U)
Hai tham số, như hàm merge của Map.merge
IntFunction, ToLongFunction, IntPredicate…
bản primitive
Tránh boxing (xem mục 6)
Tự định nghĩa khi tên nghiệp vụ dễ đọc hơn, hoặc cần ném checked exception:
@FunctionalInterfaceinterface PriceRule { long apply(long price); // abstract method duy nhất default PriceRule then(PriceRule next) { return p -> next.apply(apply(p)); } static PriceRule percentOff(int pct) { return p -> p * (100 - pct) / 100; }}PriceRule rule = PriceRule.percentOff(10).then(p -> p - 5);rule.apply(100); // 85
2. Lambda và method reference
Ý chính: lambda không phải anonymous class viết ngắn: this trỏ về class bao quanh, chỉ capture được biến cục bộ effectively final (bản sao giá trị). Khi lambda chỉ gọi một method có sẵn, method reference đọc rõ hơn.
Chi tiết về this và capture ở bài nested class và lambda. Hệ quả cho stream: lambda nên là hàm thuần (pure function: kết quả chỉ phụ thuộc đầu vào, không đổi state bên ngoài).
Bốn loại method reference:
Loại
Ví dụ
Tương đương lambda
Static method
Integer::parseInt
s -> Integer.parseInt(s)
Instance method của object cụ thể (bound)
prefix::concat
s -> prefix.concat(s)
Instance method của tham số đầu (unbound)
String::length
s -> s.length()
Constructor
ArrayList::new
() -> new ArrayList<>()
3. Stream pipeline: nguồn, trung gian, kết thúc
Ý chính: thao tác trung gian chỉ mô tả việc cần làm và trả về stream mới; thao tác kết thúc mới kéo dữ liệu qua. Mỗi phần tử đi dọc cả chuỗi trước khi phần tử sau bắt đầu, nên thao tác short-circuit dừng được sớm.
pipeline built, nothing ran yetfilter afilter bbmap bbfirst = BB
"ccc" và "dddd" không bao giờ được đọc. Lười cho phép gộp các bước vào một lần duyệt, dừng sớm, và dùng nguồn vô hạn (Stream.iterate) miễn có limit hoặc takeWhile.
Nhóm
Ví dụ
Ghi chú
Trung gian stateless
filter, map, flatMap, peek
Xử lý từng phần tử độc lập
Trung gian stateful
sorted, distinct, limit, skip
Phải nhớ phần tử đã thấy; sorted đọc hết nguồn mới trả phần tử đầu
Kết thúc short-circuit
findFirst, findAny, anyMatch, allMatch, noneMatch
Dừng khi đủ câu trả lời
Kết thúc thường
collect, reduce, count, forEach, toList
Duyệt hết
4. Các thao tác hay dùng
Ý chính:map biến một phần tử thành một phần tử; flatMap biến một phần tử thành một stream rồi trải phẳng. reduce gộp về một giá trị bất biến; collect gộp vào một container (list, map, chuỗi).
reduce(identity, op) cần opkết hợp (associative: (a op b) op c == a op (b op c)) và identity thật sự trung tính, nếu không bản parallel cho kết quả sai. Cộng, nhân, max là kết hợp; trừ thì không.
Ý chính:groupingBy chia theo một key thành Map<K, List<V>>, và nhận thêm một “downstream collector” để gộp từng nhóm. toMap cho mỗi key đúng một giá trị, nên phải nói rõ làm gì khi key trùng.
// Doanh thu PAID theo khách, map có thứ tựMap<String, Long> revenue = orders.stream() .filter(o -> o.status().equals("PAID")) .collect(groupingBy(Order::customer, TreeMap::new, summingLong(Order::amount)));// {an=320, binh=300}// Luôn có cả hai key true và falseMap<Boolean, List<String>> bigSmall = orders.stream() .collect(partitioningBy(o -> o.amount() >= 100, mapping(Order::id, toList())));// {false=[o2, o4], true=[o1, o3, o5]}orders.stream().collect(toMap(Order::customer, Order::amount));// IllegalStateException: Duplicate key an (attempted merging values 120 and 200)Map<String, Long> maxByCustomer = orders.stream() .collect(toMap(Order::customer, Order::amount, Math::max, LinkedHashMap::new));// {an=200, binh=300, chi=50}orders.stream().map(Order::id).collect(joining(", ", "[", "]")); // [o1, o2, o3, o4, o5]
Ý chính:Optional là kiểu trả về để nói “có thể không có kết quả”. Không dùng làm field, tham số method hay phần tử collection, và không gọi get() khi chưa chắc có giá trị.
orElse(x)luôn tính x, kể cả khi đã có giá trị; orElseGet(() -> x) chỉ tính khi rỗng. Mình chạy Optional.of("cached").orElse(expensive()) và expensive() vẫn được gọi. Với giá trị tốn kém (query DB, tạo object lớn) dùng orElseGet.
Không có giá trị là lỗi nghiệp vụ thì orElseThrow(() -> new OrderNotFoundException(id)).
isPresent() + get() chỉ là if (x != null) dài hơn; dùng map, filter, ifPresentOrElse. Collection rỗng tốt hơn Optional<List<T>>.
6. Primitive stream và cái giá của boxing
Ý chính:Stream<Integer> chứa object Integer; mỗi phép tính có thể tạo object mới (boxing) và đọc qua con trỏ. IntStream, LongStream, DoubleStream làm việc trực tiếp trên primitive và có sẵn sum, average, summaryStatistics.
Mình đo tổng bình phương các số chẵn trên 10 triệu số, JDK 21, Apple M4 10 nhân, median của 15 lần sau 15 lần warm-up. Đây là đo thô bằng System.nanoTime, không phải JMH, chỉ để thấy bậc độ lớn:
Cách viết
Median (ms)
Vòng for trên int[]
~21
IntStream trên int[]
~30
Vòng for trên List<Integer>
~28–34
Stream<Integer> + mapToLong + sum
~28–32
Stream<Integer> → map ra Long + reduce(0L, Long::sum)
~73
IntStream parallel (10 nhân)
~6
Vòng for nhanh hơn stream cỡ 1,5 lần ở vòng lặp cực nóng; chênh lớn nhất đến từ boxing (73 so với 30). Với vài trăm phần tử có I/O, khác biệt này không đáng kể so với một query DB. Chọn theo độ dễ đọc; dùng mapToLong/IntStream khi dữ liệu lớn.
Code benchmark và cách đọc kết quả cho đúng
cases.put("IntStream over int[]", () -> Arrays.stream(arr).filter(x -> x % 2 == 0).asLongStream().map(x -> x * x).sum());cases.put("Stream<Long> boxed + reduce", () -> list.stream().filter(x -> x % 2 == 0).map(x -> (long) x * x).reduce(0L, Long::sum));for (var e : cases.entrySet()) { for (int i = 0; i < 15; i++) check += e.getValue().getAsLong(); // warm-up cho JIT long[] t = new long[15]; for (int i = 0; i < t.length; i++) { long s = System.nanoTime(); check += e.getValue().getAsLong(); // dùng kết quả, tránh dead-code elimination t[i] = System.nanoTime() - s; } Arrays.sort(t); System.out.printf("%-30s median %6.1f ms%n", e.getKey(), t[t.length / 2] / 1e6);}
Vì sao “thô”: các case chung một JVM nên JIT profile ảnh hưởng nhau, GC không kiểm soát, ba lần chạy dao động 10–20%. Con số cho tài liệu thiết kế thì dùng JMH (fork riêng, Blackhole). Kết luận định tính (boxing tốn, parallel chỉ lời khi dữ liệu lớn) ổn định qua các lần chạy.
7. Parallel stream: khi nào không dùng
Ý chính:parallel() chia nguồn thành nhiều phần, chạy trên ForkJoinPool.commonPool() (mặc định số luồng = số nhân - 1) rồi gộp lại. Chỉ lời khi dữ liệu lớn, việc mỗi phần tử tốn CPU, nguồn chia tốt, và không có side effect.
Cùng phép tính trên 1.000 phần tử, mình đo tuần tự ~0,4 µs/lần, parallel ~16 µs/lần: chi phí chia việc lớn hơn chính công việc. Với 10 triệu phần tử thì ngược lại (~6 ms so với ~30 ms).
Không dùng parallel stream khi:
Trong request handler của web server. Mọi parallel stream trong JVM dùng chung commonPool; một request nặng chiếm hết pool làm các request khác chậm theo.
Có I/O hoặc blocking (gọi HTTP, query DB) trong lambda: thread của commonPool bị chặn, và số thread nhỏ. Việc I/O song song nên dùng executor riêng hoặc virtual thread (ExecutorService và virtual thread).
Nguồn chia kém (LinkedList, Stream.iterate) hoặc cần thứ tự (forEachOrdered, limit giữ thứ tự nhưng mất phần lớn lợi ích).
8. Những bẫy khác hay gặp
Ý chính: stream chỉ dùng được một lần, peek không đảm bảo chạy, và lambda không ném được checked exception. Cả ba đều biên dịch được và chỉ lộ ra lúc chạy hoặc làm code xấu đi.
Dùng lại stream: gọi thao tác kết thúc lần hai ném IllegalStateException: stream has already been operated upon or closed. Đừng lưu Stream vào field hay trả về để gọi nhiều lần; trả về collection, hoặc Supplier<Stream<T>> nếu thật sự cần.
Thứ tự: groupingBy mặc định trả HashMap, thứ tự không xác định; cần thứ tự thì truyền TreeMap::new.
Helper bọc checked exception và lọc phần tử lỗi bằng flatMap
@FunctionalInterfaceinterface ThrowingFunction<T, R> { R apply(T t) throws Exception; static <T, R> Function<T, R> unchecked(ThrowingFunction<T, R> f) { return t -> { try { return f.apply(t); } catch (IOException e) { throw new UncheckedIOException(e); } catch (Exception e) { throw new RuntimeException(e); } }; }}paths.stream().map(ThrowingFunction.unchecked(Files::readString)).toList();// file không tồn tại -> UncheckedIOException, cause = NoSuchFileExceptionstatic Stream<Integer> tryParse(String s) { try { return Stream.of(Integer.parseInt(s)); } catch (NumberFormatException e) { return Stream.empty(); } // bỏ phần tử lỗi, có chủ đích}List.of("1", "x", "3").stream().flatMap(Main::tryParse).toList(); // [1, 3]
Bỏ qua phần tử lỗi chỉ hợp lý khi nghiệp vụ cho phép (dữ liệu import có dòng rác). Thực tế nên đếm hoặc log số dòng bị bỏ để không mất dữ liệu trong im lặng.
Bài tập
1. Báo cáo đơn hàng
Đề: từ danh sách Order (thêm khách dung có đơn PAID 90 với SKU [B, B]), (a) lấy 2 khách có doanh thu PAID cao nhất, hoà thì theo tên; (b) đếm mỗi SKU xuất hiện trong bao nhiêu đơn (một đơn có hai B chỉ tính một), kết quả sắp theo SKU.
Lời giải Bài 1: groupingBy, sắp entry và distinct trong flatMap
Hay sai: đặt distinct() sau flatMap làm mỗi SKU chỉ còn một lần; quên thenComparing làm thứ tự khi hoà phụ thuộc HashMap. Phải ghi <String, Long> vì .reversed() làm compiler không suy được kiểu.
2. Đếm từ và sửa code có side effect
Đề: đoạn code cũ đếm từ bằng HashMap bên ngoài và forEach (lines.forEach(l -> ... map.merge(w, 1, Integer::sum))). Viết lại không có side effect, không phân biệt hoa thường, bỏ dấu câu, lấy 3 từ nhiều nhất (hoà theo bảng chữ cái). Dữ liệu: "the cat sat", "The dog sat", "a cat, a dog!".
Lời giải Bài 2: flatMap từ dòng sang từ rồi groupingBy counting
List<String> top3 = lines.stream() .flatMap(l -> Arrays.stream(l.toLowerCase().split("\\W+"))) .filter(w -> !w.isBlank()) .collect(groupingBy(Function.identity(), counting())) .entrySet().stream() .sorted(Map.Entry.<String, Long>comparingByValue().reversed() .thenComparing(Map.Entry.comparingByKey())) .limit(3) .map(e -> e.getKey() + "=" + e.getValue()) .toList();// [a=2, cat=2, dog=2] (sat và the cũng 2 lần, bị cắt theo bảng chữ cái)
filter cần vì split có thể sinh chuỗi rỗng. Bản forEach + map.merge cũ hỏng khi thêm .parallel() (HashMap không thread-safe); bản groupingBy an toàn vì mỗi luồng gộp vào map riêng rồi mới hợp lại.
Ghi nhớ
Giải thích được vì sao pipeline không có thao tác kết thúc thì không chạy, và vì sao findFirst không đọc hết nguồn.
Phân biệt được map và flatMap, stateless và stateful, toList() và Collectors.toList().
Viết được groupingBy có downstream collector, và toMap có hàm merge cùng lý do cần nó.
Biết khi nào parallel() làm chậm hoặc làm sai, và vì sao không dùng trong request handler.
Kể được ít nhất bốn bẫy: side effect, peek, dùng lại stream, orElse tính sớm, checked exception.
Câu hỏi phỏng vấn
Junior
map và flatMap khác nhau thế nào?
map biến mỗi phần tử thành đúng một phần tử; flatMap biến mỗi phần tử thành một stream (0, 1 hay nhiều phần tử) rồi trải phẳng các stream đó thành một.
Ví dụ: orders.map(Order::skus) cho Stream<List<String>>, còn orders.flatMap(o -> o.skus().stream()) cho Stream<String>. flatMap cũng dùng để lọc kết hợp biến đổi: trả Stream.empty() cho phần tử muốn bỏ. Với Optional, flatMap tránh Optional<Optional<T>>.
Thao tác trung gian và thao tác kết thúc khác nhau ra sao?
Thao tác trung gian (filter, map, sorted) trả về stream mới và lười, chưa chạy gì; thao tác kết thúc (collect, count, findFirst) tạo kết quả và kích hoạt cả pipeline.
Mỗi stream chỉ có một thao tác kết thúc; gọi thêm ném IllegalStateException. Thao tác trung gian chia thành stateless và stateful (sorted, distinct).
Mid
Vì sao stream lười? Lợi ích cụ thể là gì?
Vì lười cho phép gộp mọi bước vào một lần duyệt, dừng sớm khi đủ kết quả, và xử lý được nguồn vô hạn.
Mỗi phần tử đi dọc cả chuỗi filter → map trước khi phần tử sau bắt đầu, nên không có list trung gian nào được tạo. findFirst sau filter dừng ngay khi gặp phần tử khớp đầu tiên. Ngoại lệ là thao tác stateful như sorted: nó buộc phải đọc hết nguồn.
Collectors.toMap gặp key trùng thì sao? Xử lý thế nào?
Ném IllegalStateException: Duplicate key .... Truyền tham số thứ ba là hàm merge, hoặc dùng groupingBy nếu thật sự muốn giữ mọi giá trị.
Ví dụ toMap(Order::customer, Order::amount, Math::max) giữ đơn lớn nhất mỗi khách; Long::sum cộng dồn; (a, b) -> a giữ bản đầu. Tham số thứ tư chọn loại map (LinkedHashMap::new để giữ thứ tự). Thêm nữa, value null cũng làm toMap ném NullPointerException.
Stream.toList() khác collect(Collectors.toList()) thế nào? Thay hàng loạt có an toàn không?
Stream.toList() trả list không sửa được; Collectors.toList() hiện trả ArrayList sửa được (dù không được đặc tả). Thay hàng loạt không an toàn nếu có chỗ gọi add/remove trên kết quả.
Lỗi sẽ là UnsupportedOperationException lúc chạy, không phải lúc biên dịch. toList() vẫn nhận null, còn toUnmodifiableList() thì không. Khi migrate, tìm chỗ sửa kết quả hoặc dùng toCollection(ArrayList::new) cho chỗ cần mutable.
Senior
Khi nào bạn dùng parallel stream ở backend, và khi nào thì không?
Hầu như không dùng trong đường xử lý request. Chỉ cân nhắc cho batch CPU-bound trên dữ liệu lớn, nguồn chia tốt, không side effect, và sau khi đo.
Mọi parallel stream dùng chung ForkJoinPool.commonPool(), nên một request nặng làm chậm request khác, còn I/O trong lambda chặn số ít thread của pool. Với 1.000 phần tử mình đo parallel chậm hơn khoảng 40 lần do chi phí chia việc. Việc I/O song song dùng executor có giới hạn hoặc virtual thread; batch lớn thì thường tốt hơn là chia ở tầng job (nhiều worker, nhiều partition).
Stream có chậm hơn vòng for không? Bạn trả lời team thế nào khi họ muốn cấm stream vì hiệu năng?
Có chậm hơn một chút ở vòng lặp cực nóng (khoảng 1,5 lần trong đo thô của mình), nhưng boxing mới là thứ tốn chính (khoảng 2,4 lần). Ở code backend thường, chênh lệch này nhỏ hơn nhiều so với một lần gọi DB, nên không đáng cấm.
Mình sẽ đề nghị: dùng stream theo mặc định vì dễ đọc; dùng IntStream/mapToLong khi xử lý số lượng lớn; chỉ tối ưu sang vòng for khi profiler (async-profiler, JFR) chỉ ra đúng chỗ đó nóng, và chứng minh bằng JMH chứ không bằng System.nanoTime.
Từ vựng tiếng Anh
Term
Phát âm
Nghĩa
Ví dụ câu dùng khi phỏng vấn
functional interface
/ˈfʌŋkʃənl ˈɪntərfeɪs/
interface một abstract method
“Any lambda is an instance of some functional interface.”
intermediate operation
/ˌɪntərˈmiːdiət ˌɑːpəˈreɪʃn/
thao tác trung gian
“Intermediate operations are lazy and return a new stream.”
terminal operation
/ˈtɜːrmɪnl ˌɑːpəˈreɪʃn/
thao tác kết thúc
“Nothing runs until a terminal operation pulls the data through.”
short-circuit
/ʃɔːrt ˈsɜːrkɪt/
dừng sớm
“findFirst short-circuits, so the rest of the source is never read.”
stateful operation
/ˈsteɪtfl ˌɑːpəˈreɪʃn/
thao tác cần nhớ trạng thái
“sorted is stateful, so it has to consume the whole source first.”
downstream collector
/ˌdaʊnˈstriːm kəˈlektər/
collector gộp trong từng nhóm
“I pass summingLong as the downstream collector to groupingBy.”
merge function
/mɜːrdʒ ˈfʌŋkʃn/
hàm gộp khi trùng key
“Without a merge function, toMap throws on duplicate keys.”
boxing
/ˈbɑːksɪŋ/
bọc primitive thành object
“Boxing was the main cost, not the stream itself.”
side effect
/saɪd ɪˈfekt/
tác dụng phụ
“Lambdas in a stream should be free of side effects.”
associative
/əˈsoʊʃiətɪv/
có tính kết hợp
“The reduce operator must be associative or the parallel result is wrong.”
Ghi chép tự tổng hợp từ tài liệu chính thức và kinh nghiệm thực tế.