Java 8. Semua yang anda perlukan

Tutorial Java 8

"Jawa masih hidup dan orang ramai mula memahaminya."

Selamat datang ke pengenalan saya kepada Java 8. Artikel ini akan membawa anda langkah demi langkah melalui semua ciri baharu dari Java 7 hingga Java 8. Dengan contoh kod yang cepat dan mudah, kita boleh mempelajari cara menggunakan Antara Muka Lalai , rujukan Kaedah dan Anotasi boleh diulang . Pada akhir artikel kita akan berkenalan dengan API Strim. Tiada perbualan yang tidak perlu - hanya kod dan komen! ke hadapan!

Kaedah Lalai untuk Antara Muka

Java 8 membolehkan kami menambah kaedah bukan abstrak (yang dilaksanakan) pada antara muka dengan menambah default. Ciri ini juga dikenali sebagai Kaedah Lanjutan . Di bawah ialah contoh pertama:

interface Formula {
    double calculate(int a);

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

Selain kaedah abstrak calculate, antara muka Formulajuga mentakrifkan kaedah lalai sqrt. Kelas yang melaksanakan antara muka ini hanya perlu melaksanakan calculate. Kaedah lalai sqrtboleh digunakan di luar kotak.

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

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

Antara muka Formuladilaksanakan sebagai kelas tanpa nama. Kod adalah berlebihan: 6 baris untuk pelaksanaan sqrt(a * 100). Seperti yang akan kita lihat dalam bahagian seterusnya, terdapat cara yang lebih cantik untuk melaksanakan satu kaedah dalam Java 8.

Ungkapan Lambda

Mari kita mulakan dengan contoh mudah menyusun senarai rentetan dalam versi Java 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);
    }
});

Kaedah statik Collections.sortmenerima senarai dan pembanding dalam susunan senarai itu hendak diisih. Anda sentiasa boleh membuat kelas pembanding tanpa nama dan menyampaikannya. Daripada mencipta kelas tanpa nama, dalam Java 8 anda boleh mencipta notasi yang lebih pendek, ungkapan lambda.

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

Seperti yang anda lihat, kod itu lebih pendek dan lebih mudah dibaca. Tetapi ini boleh dibuat lebih pendek:

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

Untuk badan dengan satu baris, anda boleh melangkau {}perkataan return. Tetapi anda boleh menjadikannya lebih pendek:

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

Pengkompil Java mengetahui tentang jenis hujah, jadi anda boleh melangkaunya juga. Mari kita mendalami ungkapan lambda dan fahami cara ia boleh digunakan.

Antara Muka Berfungsi

Bagaimanakah ungkapan lambda sesuai dengan sistem jenis Java? Setiap lambda sepadan dengan jenis yang diterangkan dalam antara muka. Oleh itu, antara muka berfungsi harus mengandungi hanya satu kaedah abstrak. Setiap ungkapan lambda jenis ini akan sepadan dengan kaedah abstrak ini. Memandangkan kaedah lalai bukan abstrak, anda bebas mencipta kaedah lalai dalam antara muka berfungsi seperti yang diperlukan. Kami juga boleh menggunakan antara muka arbitrari sebagai ungkapan lambda jika terdapat hanya satu kaedah abstrak dalam antara muka ini. Untuk memenuhi keperluan ini, anda perlu menambah @FucntionalInterfaceanotasi. Pengkompil mengetahui tentangnya dan akan membuang pengecualian jika anda ingin menyediakan lebih daripada satu kaedah 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

Perlu diingat bahawa kod juga akan disusun jika @FunctionalInterfaceanotasi ditinggalkan.

Kaedah dan Rujukan Pembina

Contoh di atas juga boleh dibuat lebih kecil dengan menggunakan rujukan kaedah:

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

Java 8 membolehkan anda menghantar rujukan kepada kaedah atau pembina dengan menambah ::. Contoh di atas menunjukkan cara kita boleh merujuk kaedah statik, walaupun kita juga boleh merujuk kaedah bukan statik:

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 lihat bagaimana ::ia berfungsi dengan pembina. Untuk memulakan, kami akan menentukan kelas contoh dengan pembina yang berbeza:

class Person {
    String firstName;
    String lastName;

    Person() {}

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

Seterusnya, kami akan menentukan antara muka untuk mencipta objek baharu:

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

Daripada melaksanakan kilang penciptaan, kami akan mengikat semuanya bersama-sama dengan ::bantuan pembina:

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

Kami mencipta pautan ke pembina melalui Person::new. Pengkompil Java secara automatik akan memilih pembina yang betul yang sepadan dengan tandatangan kaedah PersonFactory.create. ... Akan bersambung. Malangnya, saya tidak menemui cara untuk menyimpan draf artikel itu, dan ini benar-benar pelik, dan masa untuk terjemahan telah tamat - jadi saya akan menyelesaikannya kemudian. Untuk semua yang tahu dan faham Bahasa Inggeris - Artikel Asal . Jika anda mempunyai cadangan untuk membetulkan terjemahan, tulis dalam sebarang cara yang tersedia untuk anda. Akaun Github saya