Biểu thức lambda trong Java: viết code hàm ngắn gọn

Hành vi có thể truyền đi

Biểu thức lambda (lambda expression) là một khối code gọn mà bạn có thể truyền cho phương thức, lưu vào biến hoặc trả về, giống như với một con số hay một chuỗi. Trước khi có lambda, muốn truyền hành vi thì phải viết cả một lớp (hoặc một lớp ẩn danh dài dòng) chỉ để bọc một phương thức. Lambda rút gọn tất cả về phần cốt lõi: tham số và phần thân.

Lambda luôn triển khai một functional interface, tức interface có đúng một phương thức trừu tượng (bạn đã gặp ở cuối trang interface). Trình biên dịch suy ra bạn đang muốn interface nào từ ngữ cảnh và ghép lambda với phương thức duy nhất đó.

interface Transformer {
    int apply(int x);
}

public class Main {
    public static void main(String[] args) {
        Transformer doubler = x -> x * 2;       // implements apply(int)
        Transformer square  = x -> x * x;

        System.out.println(doubler.apply(21));  // 42
        System.out.println(square.apply(9));     // 81
    }
}

x -> x * 2 là toàn bộ phần cài đặt của apply. Không new, không thân lớp, không tên phương thức: interface đã lo hết những thứ đó.

Cú pháp mũi tên

Lambda nào cũng có dạng parameters -> body. Các phần có thể co giãn tùy theo nhu cầu:

() -> 42                       // no parameters
x -> x + 1                     // one parameter, parentheses optional
(x, y) -> x + y                // two or more parameters need parentheses
(int x, int y) -> x + y        // types are optional - usually inferred
x -> {                          // a block body needs braces and return
    int doubled = x * 2;
    return doubled + 1;
}

Phần thân chỉ gồm một biểu thức (x -> x + 1) sẽ ngầm trả về giá trị của nó, không cần từ khóa return. Ngay khi dùng dấu ngoặc nhọn, bạn đang viết một khối lệnh bình thường và phải return tường minh nếu phương thức có trả về giá trị. Lỗi hay gặp là trộn hai cách: x -> { x + 1 } không biên dịch được, vì một khối lệnh cần một câu lệnh (return x + 1;).

Lambda thay thế lớp ẩn danh

Cách dễ thấy nhất lợi ích của lambda là so sánh trước và sau. Sắp xếp với một Comparator tùy chỉnh trước đây trông như thế này:

// before - anonymous class
names.sort(new Comparator<String>() {
    public int compare(String a, String b) {
        return a.length() - b.length();
    }
});

Viết lại bằng lambda chỉ còn một dòng dễ đọc:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>(List.of("Charlie", "Bo", "Alex"));

        names.sort((a, b) -> a.length() - b.length());   // after - lambda

        System.out.println(names);   // [Bo, Alex, Charlie]
    }
}

Comparator là một functional interface (phương thức trừu tượng duy nhất của nó là compare), nên lambda khớp vào ngay. Mọi thủ tục rườm rà như new, lớp, chữ ký phương thức đều biến mất, chỉ còn lại logic so sánh.

Bộ công cụ java.util.function

Bạn hiếm khi phải tự khai báo functional interface. Package java.util.function có sẵn các dạng thông dụng, và gần như mọi API trong thư viện Java đều nhận chúng:

• Function<T, R>: nhận một T, trả về một R (apply)
• Predicate<T>: nhận một T, trả về một boolean (test)
• Supplier<T>: không nhận gì, trả về một T (get)
• Consumer<T>: nhận một T, không trả về gì (accept)

import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

public class Main {
    public static void main(String[] args) {
        Function<String, Integer> length = s -> s.length();
        Predicate<Integer> isEven        = n -> n % 2 == 0;
        Supplier<String> greeting        = () -> "hello";

        System.out.println(length.apply("lambda"));   // 6
        System.out.println(isEven.test(10));           // true
        System.out.println(greeting.get());            // hello
    }
}

Đây là các interface generic: Function<String, Integer> dùng lại generics mà bạn đã thấy ở trang trước để giữ an toàn kiểu. Hãy chọn interface có dạng khớp với thứ code của bạn cần nhận vào và tạo ra.

Method reference

Khi một lambda không làm gì ngoài gọi một phương thức có sẵn, bạn có thể thay nó bằng một method reference (tham chiếu phương thức) dùng ::. Giá trị vẫn như cũ, chỉ là cách viết trực tiếp hơn:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> words = new ArrayList<>(List.of("pear", "fig", "apple", "kiwi"));

        // lambda:           s -> s.toUpperCase()
        // method reference: String::toUpperCase
        words.replaceAll(String::toUpperCase);
        System.out.println(words);   // [PEAR, FIG, APPLE, KIWI]

        // sort by length using a static helper as a Comparator
        words.sort((a, b) -> Integer.compare(a.length(), b.length()));
        System.out.println(words);   // [FIG, PEAR, KIWI, APPLE]
    }
}

Method reference có vài dạng: String::toUpperCase (phương thức instance được gọi trên từng đối số), Math::max (phương thức static), System.out::println (phương thức của một đối tượng cụ thể) và ArrayList::new (hàm khởi tạo). Chỉ dùng khi nó đọc rõ ràng; nếu phải nghĩ xem dạng nào áp dụng, một lambda bình thường là đủ.

Bắt giữ biến

Lambda có thể dùng biến cục bộ của phương thức bao quanh, nhưng chỉ khi biến đó là final hoặc effectively final, tức được gán một lần và không bao giờ đổi. Java bắt giữ giá trị ngay lúc lambda được tạo, nên một biến có thể đổi về sau sẽ gây mơ hồ.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        int factor = 3;                          // never reassigned -> effectively final
        Function<Integer, Integer> scale = n -> n * factor;

        System.out.println(scale.apply(10));     // 30
        // factor = 4;   // <- uncommenting this breaks the lambda above
    }
}

Nếu bạn gán lại factor ở bất kỳ đâu, trình biên dịch sẽ từ chối lambda với thông báo "variable used in lambda expression should be final or effectively final." Khi thật sự cần trạng thái dùng chung có thể thay đổi, hãy bắt giữ một đối tượng: một trường, một phần tử mảng hoặc một AtomicInteger, vì tham chiếu vẫn cố định dù nội dung bên trong thay đổi. Lưu ý rằng lambda, khác với lớp ẩn danh, không tạo phạm vi riêng: this bên trong lambda trỏ tới instance bao quanh, không phải chính lambda.

Tiếp theo: Stream

Lambda là viên gạch nền, không phải đích đến. Giá trị thật sự của nó đến cùng Streams API, nơi bạn nối các thao tác như filter, map và reduce, mỗi thao tác nhận một lambda, để diễn đạt việc biến đổi dữ liệu thành một pipeline dễ đọc thay vì một mớ vòng lặp rối rắm. Đó là nội dung của trang tiếp theo.