Ekspresi Lambda membuat kod lebih ringkas dengan memudahkan penulisan kelas dalaman tanpa nama. Sebagai contoh, gunakan (p1, p2) -> p1.getName (). CompareTo (p2.getName ()) untuk menggantikan kelas komparator tanpa nama, dan boleh menggabungkan kaedah untuk merujuk seperti orang :: getName untuk meningkatkan kebolehbacaan; 2. API Stream menyediakan saluran paip pemprosesan data deklaratif, seperti penapisan, penukaran peta, menyusun dan mengumpul hasil, dengan jelas menyatakan "apa yang perlu dilakukan" daripada "bagaimana untuk melakukannya", seperti user.stream (). 3. Perangkap biasa harus dielakkan apabila menggunakannya. Adalah disyorkan untuk memanggil penulisan cawangan dalam rantai, penapis secepat mungkin, elakkan kesan sampingan, dan gunakan Parallelstream dengan berhati -hati; 4. Penggunaan semula logik boleh dicapai dengan mengekstrak predikat dan fungsi, seperti predikat isAdult = user -> user.getage ()> = 18, dan kombinasi keadaan seperti isadult.and (user -> user.getage ()

Streams dan Lambdas yang diperkenalkan di Java 8 telah mengubah sepenuhnya cara kami memproses data pengumpulan. Mereka bukan sahaja membuat kod lebih ringkas, tetapi juga meningkatkan kebolehbacaan dan penyelenggaraan. Jika anda masih menggunakan tradisional untuk gelung untuk melintasi koleksi, menapis dan mengubah data secara manual, sudah tiba masanya untuk menaik taraf tabiat pengekodan anda.

Mari menguasai kedua -dua alat yang kuat ini langkah demi langkah dan menulis kod Java yang lebih bersih dan lebih ekspresif.

1. Ekspresi Lambda: Mengucapkan Selamat tinggal kepada Kelas Dalaman Tanpa Nama

Lambda adalah blok kod yang boleh diluluskan, yang menjadikan pengaturcaraan berfungsi mungkin di Java. Senario penggunaan yang paling biasa adalah untuk menggantikan antara muka dengan hanya satu kaedah abstrak (iaitu, antara muka berfungsi).

Contohnya: Sebelum menyusun vs selepas menyusun

 // cara tradisional: Gunakan koleksi kelas dalaman tanpa nama.sort (orang, komparator baru <erson> () {
    @Override
    Int Public Bandingkan (Person P1, Person P2) {
        kembali p1.getName (). compareTo (p2.getName ());
    }
});

//Collections.sort( orang, (p1, p2) -> p1.getName (). CompareTo (p2.getName ()));

Melangkah lebih jauh, anda juga boleh memetik dalam kombinasi dengan kaedah:

 people.sort (komparator.comparing (orang :: getName));

Antara muka berfungsi yang biasa digunakan:

• Predicate<T> : menerima parameter, mengembalikan boolean (untuk penapisan)
• Function<T, R> : terima parameter dan kembalikan hasilnya (untuk penukaran)
• Consumer<T> : Menerima parameter tanpa nilai pulangan (untuk melaksanakan operasi)
• Supplier<T> : tiada input, kembalikan nilai (digunakan untuk membuat objek)

Petua: Lambda boleh menghilangkan pengisytiharan jenis, kurungan (untuk argumen tunggal) dan pendakap (untuk pernyataan tunggal), tetapi tidak terlalu besar dan menyebabkan kebolehbacaan berkurangan.

2. API Stream: Data Proses dengan cara deklaratif

Aliran bukan struktur data, tetapi saluran paip operasi . Ia dicipta dari koleksi atau array, melalui operasi pertengahan (seperti penapis, peta), dan akhirnya menghasilkan hasil dengan menamatkan operasi (seperti mengumpul, foreach).

Struktur Asas:

 list.stream ()
    .filter (keadaan)
    .map (transformasi)
    .sorted ()
    .kolect (collectors.tolist ());

Contoh praktikal: cari nama pengguna lebih tua dari 25 dan menyusunnya secara abjad

 Senaraikan <string> names = users.stream ()
    .filter (user -> user.getage ()> 25)
    .map (pengguna :: getName)
    .sorted ()
    .kolect (collectors.tolist ());

Kod ini jelas menyatakan "apa yang kita mahu" daripada "bagaimana untuk melakukannya langkah demi langkah".

Operasi perantaraan biasa:

• filter(Predicate) : Unsur penapis yang memenuhi kriteria
• map(Function) : Tukar setiap elemen
• flatMap : Memperluas setiap elemen dalam aliran ke dalam pelbagai elemen (seperti senarai Diratakan)
• distinct() : deduplicate
• limit(n) / skip(n) : kawalan penomboran

Operasi penamatan biasa:

• collect() : Kumpulkan hasil (yang paling biasa digunakan)
• forEach() : Pelaksanaan operasi traversal
• count() : kiraan
• anyMatch() / allMatch() / noneMatch() : Tentukan sama ada terdapat elemen yang memenuhi syarat

3. Elakkan perangkap biasa

Walaupun sungai dan lambdas berkuasa, mereka juga mudah disalahgunakan.

? Adalah disyorkan untuk melakukan ini:

• Panggilan rantai harus jelas : Setiap operasi mengambil satu baris untuk debugging dan bacaan mudah.
• Penapis secepat mungkin : Letakkan filter di hadapan untuk mengurangkan jumlah data untuk operasi berikutnya.
• Elakkan kesan sampingan : Jangan mengubah suai pembolehubah luaran di lambda, terutamanya dalam persekitaran serentak.
• Berhati -hati apabila menggunakan aliran selari : parallelStream() tidak selalunya lebih cepat dan hanya dipertimbangkan apabila jumlah data besar dan operasi adalah bebas.

? Tidak disyorkan kaedah penulisan:

 users.stream ()
     .map (pengguna -> {
         System.out.println (pengguna); // tidak disyorkan: lakukan kesan sampingan dalam peta pulangan user.getName ();
     })
     .Foreach (System.out :: println);

Harus diubah menjadi:

 users.stream ()
     .map (pengguna :: getName)
     .Foreach (System.out :: println); // atau berpecah logik

4. Kemahiran Praktikal: gabungan dan penggunaan semula

Anda boleh mengekstrak predikat atau fungsi yang biasa digunakan dan menggunakannya semula:

 Predicate <user> isAdult = user -> user.getage ()> = 18;
Fungsi <user, string> toname = user :: getName;

Senaraikan <string> orang dewasa = users.stream ()
    .filter (isadult)
    .map (toname)
    .kolect (collectors.tolist ());

Malah keadaan boleh digabungkan:

 Predicate <user> isyoungadult = isAdult.and (user -> user.getage () <30);

Pada dasarnya itu sahaja. Idea utama aliran dan lambdas adalah: nyatakan lebih banyak niat dengan kod kurang . Anda tidak boleh digunakan untuk gaya berfungsi pada mulanya, tetapi sebaik sahaja anda menguasainya, anda akan mendapati bahawa logik berpuluh -puluh garisan terdahulu dapat diselesaikan dalam beberapa baris sekarang, dan lebih selamat dan lebih mudah untuk diuji.

Tidak rumit, tetapi mudah untuk mengabaikan butiran. Tulis lebih lanjut, baca lebih lanjut, dan refactor lebih banyak, dan anda juga boleh menulis "Kod Java yang sangat maju".

Atas ialah kandungan terperinci Menguasai Java 8 Streams dan Lambdas untuk Kod Pembersih. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!