Java 8. Semua yang Anda butuhkan

Tutorial Java 8

“Jawa masih hidup dan orang-orang mulai memahaminya.”

Selamat datang di perkenalan saya tentang Java 8. Artikel ini akan membawa Anda langkah demi langkah melalui semua fitur baru dari Java 7 hingga Java 8. Dengan contoh kode yang cepat dan sederhana, kita dapat mempelajari cara menggunakan Antarmuka Default, Referensi Metode , dan Anotasi yang dapat diulang . Di akhir artikel kita akan berkenalan dengan Stream API. Tidak ada obrolan yang tidak perlu - cukup kode dan komentar! Maju!

Metode Default untuk Antarmuka

Java 8 memungkinkan kita menambahkan metode non-abstrak (yang diimplementasikan) ke antarmuka dengan menambahkan ekstensi default. Fitur ini juga dikenal sebagai Metode Ekstensi . Di bawah ini adalah contoh pertama:

interface Formula {
    double calculate(int a);

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

Selain metode abstrak calculate, antarmuka Formulajuga mendefinisikan metode default sqrt. Kelas yang mengimplementasikan antarmuka ini hanya perlu mengimplementasikan calculate. Metode default sqrtdapat digunakan secara langsung.

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

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

Antarmuka Formuladiimplementasikan sebagai kelas anonim. Kode ini mubazir: 6 baris untuk implementasi sqrt(a * 100). Seperti yang akan kita lihat di bagian selanjutnya, ada cara yang lebih bagus untuk mengimplementasikan satu metode di Java 8.

Ekspresi Lambda

Mari kita mulai dengan contoh sederhana mengurutkan daftar string di Java versi sebelumnya:

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);
    }
});

Metode statis Collections.sortmenerima daftar dan pembanding dalam urutan pengurutan daftar. Anda selalu dapat membuat kelas pembanding anonim dan menyebarkannya. Daripada membuat kelas anonim, di Java 8 Anda bisa menulis formulir yang lebih pendek, ekspresi lambda.

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

Seperti yang Anda lihat, kodenya jauh lebih pendek dan lebih mudah dibaca. Tapi ini bisa dibuat lebih singkat lagi:

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

Untuk isi dengan satu baris, Anda dapat melewatkan {}kata return. Tapi Anda bisa membuatnya lebih pendek lagi:

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

Kompiler Java mengetahui tentang tipe argumen, sehingga Anda dapat melewatinya juga. Mari gali lebih dalam ekspresi lambda dan pahami cara penggunaannya.

Antarmuka Fungsional

Bagaimana ekspresi lambda cocok dengan sistem tipe Java? Setiap lambda sesuai dengan tipe yang dijelaskan di antarmuka. Oleh karena itu, antarmuka fungsional hanya boleh berisi satu metode abstrak. Setiap ekspresi lambda jenis ini akan sesuai dengan metode abstrak ini. Karena metode default tidak abstrak, Anda bebas membuat metode default di antarmuka fungsional sesuai kebutuhan. Kita juga dapat menggunakan antarmuka arbitrer sebagai ekspresi lambda jika hanya ada satu metode abstrak di antarmuka ini. Untuk memenuhi persyaratan ini, Anda perlu menambahkan @FucntionalInterfaceanotasi. Kompiler mengetahuinya dan akan memberikan pengecualian jika Anda ingin menyediakan lebih dari satu metode abstrak. Contoh:

@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

Ingatlah bahwa kode juga akan dikompilasi jika @FunctionalInterfaceanotasi dihilangkan.

Referensi Metode dan Konstruktor

Contoh di atas juga bisa dibuat lebih kecil lagi dengan menggunakan referensi metode:

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

Java 8 memungkinkan Anda meneruskan referensi ke metode atau konstruktor dengan menambahkan ::. Contoh di atas menunjukkan bagaimana kita bisa mereferensikan metode statis, meskipun kita juga bisa mereferensikan metode non-statis:

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"

Mari kita lihat cara ::kerjanya dengan konstruktor. Untuk memulai, kita akan mendefinisikan contoh kelas dengan konstruktor berbeda:

class Person {
    String firstName;
    String lastName;

    Person() {}

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

Selanjutnya, kita akan mendefinisikan antarmuka untuk membuat objek baru:

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

Daripada menerapkan pabrik pembuatan, kami akan menggabungkan semuanya dengan ::bantuan konstruktor:

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

Kami membuat tautan ke konstruktor melalui Person::new. Kompiler Java akan secara otomatis memilih konstruktor yang benar yang cocok dengan tanda tangan metode PersonFactory.create. ... Bersambung. Sayangnya, saya tidak menemukan cara untuk menyimpan draf artikel, dan ini sungguh aneh, dan waktu penerjemahannya sudah habis - jadi saya akan menyelesaikannya nanti. Untuk semua orang yang mengetahui dan memahami bahasa Inggris - Artikel Asli . Jika Anda memiliki saran untuk mengoreksi terjemahan, tulislah dengan cara apa pun yang tersedia bagi Anda. Akun Github saya