Java 8. Mọi thứ bạn cần

Hướng dẫn Java 8

"Java vẫn còn tồn tại và mọi người đang bắt đầu hiểu nó."

Chào mừng bạn đến với phần giới thiệu của tôi về Java 8. Bài viết này sẽ hướng dẫn bạn từng bước qua tất cả các tính năng mới từ Java 7 đến Java 8. Với các ví dụ mã nhanh và đơn giản, chúng ta có thể tìm hiểu cách sử dụng Giao diện mặc định, tham chiếu Phương thức và Chú thích có thể lặp lại Cuối bài chúng ta sẽ làm quen với Stream API. Không có những cuộc trò chuyện không cần thiết - chỉ cần viết mã và nhận xét! Phía trước!

Phương thức mặc định cho giao diện

Java 8 cho phép chúng ta thêm các phương thức không trừu tượng (được triển khai) vào các giao diện bằng cách thêm phần mở rộng default. Tính năng này còn được gọi là Phương pháp mở rộng . Dưới đây là ví dụ đầu tiên:

interface Formula {
    double calculate(int a);

    default double sqrt(int a) {
        return Math.sqrt(a);
    }
}

Ngoài phương thức trừu tượng calculate, giao diện Formulacòn định nghĩa một phương thức mặc định sqrt. Các lớp triển khai giao diện này chỉ cần triển khai calculate. Phương pháp mặc định sqrtcó thể được sử dụng ngay lập tức.

Formula formula = new Formula() {
    @Override
    public double calculate(int a) {
        return sqrt(a * 100);
    }
};

formula.calculate(100);     // 100.0
formula.sqrt(16);           // 4.0

Giao diện Formulađược triển khai như một lớp ẩn danh. Mã này dư thừa: 6 dòng để thực hiện sqrt(a * 100). Như chúng ta sẽ thấy trong phần tiếp theo, có một cách hay hơn để triển khai một phương thức duy nhất trong Java 8.

Biểu thức Lambda

Hãy bắt đầu với một ví dụ đơn giản về sắp xếp danh sách các chuỗi trong các phiên bản Java trước đó:

List<String> names = Arrays.asList("peter", "anna", "mike", "xenia");

Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
        return b.compareTo(a);
    }
});

Phương thức tĩnh Collections.sortchấp nhận một danh sách và một bộ so sánh theo thứ tự sắp xếp danh sách. Bạn luôn có thể tạo một lớp so sánh ẩn danh và chuyển nó đi. Thay vì tạo một lớp ẩn danh, trong Java 8 bạn có thể tạo một ký hiệu ngắn hơn, biểu thức lambda.

Collections.sort(names, (String a, String b) -> {
    return b.compareTo(a);
});

Như bạn có thể thấy mã ngắn hơn và dễ đọc hơn nhiều. Nhưng điều này có thể được thực hiện thậm chí còn ngắn hơn:

Collections.sort(names, (String a, String b) -> b.compareTo(a));

Đối với nội dung có một dòng, bạn có thể bỏ qua {}từ return. Nhưng bạn có thể làm cho nó ngắn hơn nữa:

Collections.sort(names, (a, b) -> b.compareTo(a));

Trình biên dịch Java biết về các loại đối số nên bạn cũng có thể bỏ qua chúng. Hãy cùng tìm hiểu sâu hơn về biểu thức lambda và hiểu cách sử dụng chúng.

Giao diện chức năng

Làm thế nào để các biểu thức lambda phù hợp với hệ thống kiểu Java? Mỗi lambda tương ứng với một loại được mô tả trong giao diện. Do đó, một giao diện chức năng chỉ nên chứa một phương thức trừu tượng. Mọi biểu thức lambda thuộc loại này sẽ tương ứng với phương thức trừu tượng này. Vì các phương thức mặc định không trừu tượng nên bạn có thể tự do tạo các phương thức mặc định trong giao diện chức năng nếu cần. Chúng ta cũng có thể sử dụng các giao diện tùy ý làm biểu thức lambda nếu chỉ có một phương thức trừu tượng trong giao diện này. Để đáp ứng những yêu cầu này, bạn cần thêm @FucntionalInterfacechú thích. Trình biên dịch biết về điều đó và sẽ đưa ra một ngoại lệ nếu bạn muốn cung cấp nhiều hơn một phương thức trừu tượng. Ví dụ:

@FunctionalInterface
interface Converter<F, T> {
    T convert(F from);
}

Converter<String, Integer> converter = (from) -> Integer.valueOf(from);
Integer converted = converter.convert("123");
System.out.println(converted);    // 123

Hãy nhớ rằng mã cũng sẽ biên dịch nếu @FunctionalInterfacechú thích bị bỏ qua.

Tài liệu tham khảo về phương thức và hàm tạo

Ví dụ trên cũng có thể được làm nhỏ hơn nữa bằng cách sử dụng tham chiếu phương thức:

Converter<String, Integer> converter = Integer::valueOf;
Integer converted = converter.convert("123");
System.out.println(converted);   // 123

Java 8 cho phép bạn truyền tham chiếu đến một phương thức hoặc hàm tạo bằng cách thêm ::. Ví dụ trên cho thấy cách chúng ta có thể tham chiếu một phương thức tĩnh, mặc dù chúng ta cũng có thể tham chiếu các phương thức không tĩnh:

class Something {
    String startsWith(String s) {
        return String.valueOf(s.charAt(0));
    }
}

Something something = new Something();
Converter<String, String> converter = something::startsWith;
String converted = converter.convert("Java");
System.out.println(converted);    // "J"

Hãy xem ::nó hoạt động như thế nào với các nhà xây dựng. Để bắt đầu, chúng ta sẽ định nghĩa một lớp mẫu với các hàm tạo khác nhau:

class Person {
    String firstName;
    String lastName;

    Person() {}

    Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}

Tiếp theo, chúng ta sẽ xác định giao diện để tạo các đối tượng mới:

interface PersonFactory<P extends Person> {
    P create(String firstName, String lastName);
}

Thay vì triển khai một nhà máy sản xuất, chúng ta sẽ liên kết tất cả lại với nhau bằng ::sự trợ giúp của hàm tạo:

PersonFactory<Person> personFactory = Person::new;
Person person = personFactory.create("Peter", "Parker");

Chúng tôi đã tạo một liên kết đến hàm tạo thông qua Person::new. Trình biên dịch Java sẽ tự động chọn hàm tạo phù hợp với chữ ký phương thức PersonFactory.create. ... Còn tiếp. Thật không may, tôi không tìm được cách lưu bản nháp của bài viết, và điều này thực sự kỳ lạ, và thời gian dịch đã hết - vì vậy tôi sẽ hoàn thành nó sau. Dành cho tất cả những ai biết và hiểu tiếng Anh - Bài viết gốc . Nếu bạn có đề xuất sửa bản dịch, hãy viết theo bất kỳ cách nào bạn có thể. Tài khoản Github của tôi