Java 8 dan versi berikutnya telah memperkenalkan beberapa ciri utama, dengan ketara meningkatkan kesederhanaan, keselamatan dan pemeliharaan kod. 1. Ekspresi Lambda membenarkan fungsi diluluskan sebagai parameter, memudahkan penulisan kelas dalaman tanpa nama, dan sesuai untuk pelaksanaan antara muka berfungsi; 2. API Stream menyokong pemprosesan deklaratif data pengumpulan, dan meningkatkan keupayaan pemprosesan data melalui rantai operasi seperti penapis dan peta, tetapi perhatian harus dibayar kepada prestasi dan senario logik yang mudah; 3. 4. Lalai antara muka dan kaedah statik meningkatkan keupayaan pengembangan antara muka, elakkan memusnahkan pelaksanaan sedia ada, dan sesuai untuk menambah kaedah keserasian atau kaedah alat; 5. Rekod secara automatik menjana sama, hashcode dan kaedah lain, yang sesuai untuk model data yang tidak berubah, memudahkan definisi POJO; 6. Pemadanan Corak Instanceof mengurangkan kod berlebihan untuk penukaran jenis, dan meningkatkan kebolehbacaan kod. Ciri -ciri ini bersama -sama mempromosikan Java untuk berkembang dalam arah yang lebih moden dan cekap.

Java 8 adalah titik perubahan utama untuk bahasa, memperkenalkan ciri -ciri yang mengubah cara pemaju menulis kod. Dan sejak itu, Java terus berkembang dengan setiap versi baru yang membawa keupayaan moden. Sekiranya anda bekerja dengan Java hari ini-terutamanya dalam persekitaran perusahaan atau aplikasi berskala besar-memahami ciri-ciri moden ini boleh menjadikan kod anda lebih bersih, lebih selamat, dan mudah dikekalkan.

Berikut adalah pecahan beberapa ciri bahasa Java 8 utama yang bernilai mendapat selesa.

1. Ekspresi Lambda (Java 8)

Ekspresi Lambda membolehkan anda merawat fungsi sebagai hujah kaedah, atau "kod lulus" seperti data. Mereka amat berguna apabila bekerja dengan koleksi atau pengendalian acara.

Sebelum Java 8, jika anda ingin lulus tingkah laku ke dalam kaedah (seperti menyusun senarai), anda perlu membuat kelas dalaman tanpa nama. Dengan lambdas, ia lebih bersih:

 // Sebelum: Menggunakan kelas tanpa nama
Senarai <string> names = arrays.aslist ("John", "Anna", "Mike");
COLLECTIONS.SORT (nama, komparator baru <string> () {
    Int Public Compare (String A, String b) {
        kembali A.CompareTo (b);
    }
});

// selepas: menggunakan lambda
Koleksi.sort (nama, (a, b) -> a.compareto (b));

Petua:

• Gunakan lambdas semasa melaksanakan antara muka berfungsi (antara muka dengan satu kaedah abstrak).
• Jangan terlalu banyak menggunakannya dalam logik yang kompleks -ia boleh menyakiti kebolehbacaan.
• Gabungkan mereka dengan Stream API untuk pemprosesan data yang kuat.

2. API Stream (Java 8)

API Stream membolehkan anda memproses urutan elemen secara deklaratif. Ia berfungsi dengan baik dengan koleksi dan operasi sokongan seperti penapisan, pemetaan, dan mengurangkan.

Sebagai contoh, jika anda ingin menapis senarai nombor dan dapatkan hanya:

 Senarai <Integer> nombor = arrays.aslist (1, 2, 3, 4, 5, 6);
Senaraikan <Enteger> evens = number.stream ()
                                .filter (n -> n % 2 == 0)
                                .kolect (collectors.tolist ());

Apa yang Perlu Tahu:

• Aliran bukan koleksi -mereka pembalut di sekitar sumber data.
• Anda boleh berantai operasi ( filter , map , sorted ) dengan mudah.
• Operasi perantaraan (seperti filter ) malas; Mereka tidak berlari sehingga operasi terminal (seperti collect ) dipanggil.

Gunakan aliran ketika:

• Anda perlu mengubah atau menapis data dalam koleksi.
• Anda ingin menyatakan niat dengan jelas (misalnya, "Cari semua pengguna lebih dari 30").

Elakkan sungai ketika:

• Prestasi adalah kritikal (mereka menambah overhead).
• Logiknya sangat mudah -kadang -kadang gelung lebih jelas.

3. Kelas Pilihan (Java 8)

Optional<T> membantu mengurangkan pengecualian penunjuk null dengan membuatnya jelas apabila nilai mungkin tidak hadir. Daripada kembali null , anda mengembalikan Optional .

 Pilihan <string> maybename = getNamebyId (123);
maybename.ifPresent (name -> System.out.println ("Found name:" name));

Cara menggunakannya:

• Gunakan Optional.ofNullable() apabila nilai mungkin null.
• Elakkan memanggil .get() tanpa memeriksa .isPresent() .
• Jangan pulangkan Optional dari setter atau pembina -ini dimaksudkan untuk jenis pulangan.

Ini adalah amalan yang baik untuk:

• Kembalikan Optional dari kaedah yang mungkin tidak menemui hasilnya.
• Operasi rantai menggunakan map , flatMap , atau orElse .

4. Kaedah lalai dan statik dalam antara muka (Java 8)

Sebelum Java 8, antara muka hanya dapat mengisytiharkan kaedah -tidak menyediakan pelaksanaan. Sekarang, anda boleh menentukan kaedah lalai dan statik secara langsung dalam antara muka.

 Logger antara muka awam {
    void log (mesej rentetan);

    lalai void logWithTimeStamp (mesej string) {
        System.out.println (localDateTime.Now () ":" Mesej);
    }

    statik logger getDefaultLogger () {
        kembali msg -> System.out.println (MSG);
    }
}

Ini menjadikannya lebih mudah untuk mengembangkan antara muka tanpa melanggar pelaksanaan sedia ada. Ia juga membolehkan tingkah laku seperti utiliti di dalam antara muka.

Bila hendak menggunakan:

• Tambah kaedah serasi ke belakang ke antara muka sedia ada.
• Menyediakan kaedah utiliti biasa dalam antara muka (sebagai kaedah statik).

Ingatlah:

• Kaedah lalai boleh menyebabkan konflik jika dua antara muka menentukan yang sama -anda perlu menyelesaikannya secara manual.
• Jangan keterlaluan -menyimpan antara muka yang memberi tumpuan kepada tingkah laku.

5. Rekod (Java 16)

Rekod adalah cara ringkas untuk memodelkan kelas data yang tidak berubah. Mereka secara automatik menjana equals() , hashCode() , toString() , dan aksesor.

Daripada menulis ini:

 orang kelas awam {
    Nama rentetan akhir peribadi;
    umur akhir persendirian;

    orang awam (nama rentetan, int umur) {
        this.name = name;
        this.age = umur;
    }

    // getters, sama, hashcode, toString ...
}

Anda boleh lakukan:

 Orang Rekod Awam (Nama String, Int Age) {}

Mata Utama:

• Rekod adalah muktamad dan tidak boleh dilanjutkan.
• Mereka sempurna untuk DTO, model data, atau mana -mana kes di mana anda memerlukan objek yang mudah berubah.
• Anda masih boleh menambah kaedah tersuai atau logik pengesahan jika diperlukan.

6. Pencocokan corak misalnya (Java 16)

Sebelum Java 16, anda terpaksa membuang selepas memeriksa jenis:

 jika (OBJ Instanceof String) {
    String s = (String) OBJ;
    System.out.println (s.length ());
}

Sekarang anda boleh menggabungkan cek dan pelakon:

 jika (obj instanceof string s) {
    System.out.println (s.length ());
}

Ini mengurangkan boilerplate dan meningkatkan kebolehbacaan. Ia juga berfungsi dengan corak switch dalam versi yang lebih baru.

Java moden memberi anda alat untuk menulis kod yang lebih ekspresif dan kurang rawan. Walaupun anda tidak perlu menggunakan setiap ciri dengan segera, memahami apa yang ada -dan bila menggunakannya -boleh membantu anda menulis perisian yang lebih baik. Sesetengah ciri seperti rekod atau pencocokan corak berasa kecil tetapi membuat perbezaan yang ketara sebaik sahaja anda mula menggunakannya dengan kerap.

Pada dasarnya itu sahaja.

Atas ialah kandungan terperinci Meneroka Ciri Bahasa Java 8 Moden. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!