Lambda và functional interface là gì?

Question

Accepted Answer

**Lambda** (Java 8+) là các hàm vô danh (anonymous function) súc tích, và một **functional interface** là một interface có chính xác **một method trừu tượng** — kiểu đích mà một lambda implement. Cùng nhau, chúng mang lập trình hàm vào Java và là nền tảng của Stream API. ## Một functional interface ```java @FunctionalInterface // annotation tùy chọn — ép buộc chỉ MỘT method trừu tượng interface Calculator { int calculate(int a, int b); // method trừu tượng duy nhất } ``` Một interface có một method trừu tượng là "functional" — một lambda có thể implement nó vì không có sự mơ hồ về việc lambda đại diện cho method nào. ## Cú pháp lambda — implement nó một cách súc tích ```java // ❌ anonymous class dài dòng (trước Java 8) Calculator add = new Calculator() { public int calculate(int a, int b) { return a + b; } }; // ✅ lambda — cùng một thứ, ít boilerplate hơn nhiều Calculator add = (a, b) -> a + b; Calculator multiply = (a, b) -> a * b; add.calculate(2, 3); // 5 ``` Lambda `(a, b) -> a + b` cung cấp phần implement cho method duy nhất — không có class, không có boilerplate chữ ký method. ## Các functional interface có sẵn (java.util.function) ```java Function length = s -> s.length(); // nhận T, trả về R Predicate isPositive = n -> n > 0; // nhận T, trả về boolean Consumer printer = s -> System.out.println(s); // nhận T, trả về void Supplier greeting = () -> "Hello"; // không nhận gì, trả về T BiFunction sum = (a, b) -> a + b; // hai tham số ``` Java cung cấp sẵn các functional interface cho những dạng phổ biến, được dùng xuyên suốt thư viện chuẩn (đặc biệt là stream). ## Method reference — còn ngắn hơn nữa ```java // khi một lambda chỉ gọi một method có sẵn, hãy dùng method reference list.forEach(System.out::println); // thay vì x -> System.out.println(x) list.stream().map(String::toUpperCase); // thay vì s -> s.toUpperCase() list.stream().map(Integer::parseInt); // method reference tĩnh ``` ## Nơi lambda tỏa sáng ```java // truyền hành vi như là tham số — yếu tố cốt lõi tạo nên Stream API people.stream() .filter(p -> p.getAge() > 18) // Predicate lambda .map(Person::getName) // method reference .forEach(System.out::println); // Consumer list.sort((a, b) -> a.compareTo(b)); // Comparator lambda button.addActionListener(e -> handleClick()); // bộ xử lý sự kiện ``` ## Tại sao điều này quan trọng Lambda và functional interface mang lập trình hàm vào Java, thay đổi căn bản cách viết Java hiện đại. Chúng loại bỏ boilerplate dài dòng của anonymous class cho việc truyền **hành vi như là dữ liệu**, cho phép viết các bộ xử lý sự kiện, comparator, callback súc tích, và — quan trọng nhất — toàn bộ **Stream API** (vốn phụ thuộc vào lambda cho các phép toán filter/map/reduce của nó). Hiểu rằng một lambda nhắm vào một functional interface (một method trừu tượng), các interface có sẵn (Function, Predicate, Consumer, Supplier), và method reference là thiết yếu để viết Java hiện đại đúng phong cách và dùng hiệu quả stream, collection, và các API concurrent. Chúng đại diện cho một bước tiến lớn của ngôn ngữ và là cốt lõi của sự thành thạo Java hiện hành.