Menguasai Ungkapan Lambda dalam Java Panduan Komprehensif

Pengenalan kepada Ungkapan Lambda dalam Java

Walaupun banyak versi Java baharu dikeluarkan, Java 8 kekal sebagai salah satu versi yang paling banyak diterima pakai kerana ciri yang berkuasa dan transformatifnya. Lambda Expressions, yang diperkenalkan dalam Java 8, amat popular kerana ia menjadikan Java lebih ringkas dan cekap dengan mendayakan pengaturcaraan berfungsi. Ciri ini membolehkan pembangun menggantikan kelas dalaman tanpa nama bertele-tele dengan sintaks yang diperkemas, menjadikan kod lebih mudah dibaca dan diselenggara.

Dalam panduan ini, kami akan meneroka cara Lambda Expressions memudahkan kod, meningkatkan pemprosesan data dalam koleksi dan membolehkan pembangun Java menulis aplikasi moden yang berprestasi.

Memahami Ungkapan Lambda: Asas

Pada terasnya, Ungkapan Lambda ialah cara untuk mewakili kaedah abstrak tunggal antara muka berfungsi dalam sintaks yang lebih mudah. Ciri ini sejajar dengan konsep Kaedah Abstrak Tunggal (SAM), yang membenarkan antara muka dengan kaedah tunggal yang tidak dilaksanakan untuk dianggap sebagai serasi Lambda.

Sintaks Lambda:
Ungkapan Lambda biasanya terdiri daripada tiga bahagian:

1. Senarai Parameter – Nilai input yang diperlukan untuk fungsi.
2. Token Anak Panah (->) – Mengasingkan parameter daripada badan fungsi.
3. Body – Blok kod yang melaksanakan operasi, yang boleh menjadi ungkapan atau blok kod yang disertakan dalam pendakap kerinting.

(parameters) -> expression
(parameters) -> { statements; }

Contoh Ungkapan Lambda:

• Ungkapan Lambda asas yang mengambil dua integer dan mengembalikan jumlahnya:

  (int x, int y) -> x + y

• Ungkapan Lambda yang mengambil satu rentetan dan mencetaknya:

  (String message) -> System.out.println(message)

Sintaks Lambda Expressions dalam Java adalah fleksibel dan intuitif, membolehkan pembangun memilih antara format ringkas, satu baris atau blok yang lebih terperinci apabila berbilang baris kod diperlukan.

Cara Ungkapan Lambda Memudahkan Kod Java

Sebelum Java 8, melaksanakan antara muka seperti Runnable atau Comparator memerlukan kelas dalaman tanpa nama. Lambda Expressions menyelaraskan proses ini, menggantikan kod boilerplate dengan gaya yang lebih berfungsi. Berikut ialah perbandingan cara Lambda Expression memudahkan tugas biasa:

Contoh 1: Menggunakan Ungkapan Lambda dengan Runnable

Pertimbangkan pelaksanaan Runnable yang mudah. Menggunakan kelas dalaman tanpa nama akan kelihatan seperti ini:

Runnable r1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello world one!");
    }
};

Dengan Ungkapan Lambda, kod ini boleh dipermudahkan kepada:

(parameters) -> expression
(parameters) -> { statements; }

Ungkapan Lambda dengan Antara Muka Fungsian Biasa

Java 8 memperkenalkan satu set antara muka berfungsi yang telah ditetapkan dalam pakej java.util.function. Antara muka ini, seperti Predikat, Fungsi, Pengguna dan Pembekal, menyediakan asas untuk Lambda Expressions, membolehkan pembangun memanfaatkan prinsip pengaturcaraan berfungsi.

1. Predikat – Mewakili syarat, mengembalikan benar atau salah berdasarkan input.
2. Fungsi – Menerima satu hujah dan menghasilkan keputusan.
3. Pengguna – Melakukan tindakan pada satu input tanpa mengembalikan hasil.
4. Pembekal – Menyediakan output tanpa mengambil sebarang input.

Dengan menggunakan antara muka ini dengan Lambda Expressions, pembangun Java boleh melaksanakan operasi yang bukan sahaja ringkas tetapi juga sangat boleh digunakan semula.

Kes Penggunaan Dunia Sebenar untuk Ungkapan Lambda

Untuk melihat Ungkapan Lambda dalam tindakan, mari kita lihat beberapa senario yang mempamerkan cara ia boleh menggantikan sintaks verbose, memperkemas operasi biasa dan meningkatkan kebolehbacaan.

Contoh Lambda Boleh Lari

Antara muka Runnable dalam Java mewakili tugasan yang boleh dilaksanakan oleh benang. Kelas mesti menentukan kaedah tanpa argumen yang dipanggil run. Begini cara Lambda Expression memudahkan pelaksanaan Runnable.

Boleh Dijalankan dengan Kelas Dalaman Tanpa Nama:

  (int x, int y) -> x + y

Boleh Dijalankan dengan Ekspresi Lambda:

  (String message) -> System.out.println(message)

Menggunakan Lambda Expressions mengurangkan lima baris kod kepada satu, menyerlahkan cara ia boleh memudahkan kod Java.

Contoh Lambda Pembanding

Antara muka Pembanding sering digunakan untuk menentukan logik pengisihan untuk koleksi. Dengan Lambda Expressions, mentakrifkan kriteria pengisihan tersuai menjadi lebih ringkas dan intuitif.

Pembanding untuk Mengisih Senarai Orang mengikut Nama Keluarga:

Runnable r1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello world one!");
    }
};

Ungkapan Lambda memudahkan anda bertukar antara susunan urutan dengan menukar logik perbandingan, mis., untuk tertib menurun:

Runnable r2 = () -> System.out.println("Hello world two!");

Pendekatan ini amat berguna dalam aplikasi yang memerlukan pengisihan dinamik, membolehkan pembangun menukar kriteria pengisihan dengan mudah berdasarkan input pengguna atau syarat lain.

Menggunakan Ungkapan Lambda dengan Pendengar Acara

Dalam pengaturcaraan GUI, pendengar acara biasanya digunakan untuk mengendalikan tindakan pengguna. Secara tradisinya, kelas dalaman tanpa nama diperlukan, menghasilkan kod yang panjang. Lambda Expressions, bagaimanapun, menawarkan cara yang lebih bersih untuk melaksanakan pendengar ini.

ActionListener dengan Kelas Dalaman Tanpa Nama:

Runnable r1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("Running with anonymous inner class");
    }
};
r1.run();

ActionListener dengan Lambda Expression:

(parameters) -> expression
(parameters) -> { statements; }

Lambda Expressions membolehkan pembangun melaksanakan ActionListener secara langsung dalam satu baris, meningkatkan kebolehbacaan dan mengurangkan kod boilerplate.

Kes Penggunaan Terperinci: Penapisan dengan Predikat

Senario biasa dalam aplikasi perisian ialah menapis data berdasarkan berbilang kriteria. Di Java, ini boleh dikendalikan dengan berkesan dengan menggabungkan Ungkapan Lambda dengan antara muka Predikat, membenarkan penapisan dinamik koleksi.

Pertimbangkan senarai objek Orang, tempat kami ingin menapis berdasarkan kriteria yang berbeza, seperti umur dan jantina.

Mentakrifkan Kelas Kriteria Carian berasaskan Predikat:

  (int x, int y) -> x + y

Kelas SearchCriteria merangkum syarat biasa untuk menapis senarai, membenarkan fleksibiliti dalam menggunakan penapis berbeza pada satu koleksi.

Menggunakan Kriteria dalam Penapisan:

  (String message) -> System.out.println(message)

Pendekatan ini menghapuskan keperluan untuk berbilang untuk gelung, menyediakan penyelesaian yang lebih bersih, boleh digunakan semula dan lebih boleh diselenggara.

API Strim dan Koleksi dengan Ungkapan Lambda

API Stream Java 8 merevolusikan cara pengumpulan diproses, terutamanya dengan Lambda Expressions yang membolehkan penapisan, transformasi dan pengagregatan data yang cekap. Strim membenarkan pemprosesan yang malas, di mana data diproses hanya apabila diperlukan, meningkatkan prestasi untuk set data yang besar.

Gelung dengan forEach

Kaedah forEach dalam API Strim menyediakan alternatif kepada gelung tradisional, membolehkan Ungkapan Lambda digunakan pada setiap elemen dalam koleksi. Berikut ialah contoh yang berulang melalui senarai objek Orang.

Runnable r1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello world one!");
    }
};

Menggunakan Rujukan Kaedah:
Untuk kes di mana kaedah sedia ada boleh digunakan semula, Java membenarkan rujukan kaedah, satu trengkas yang meningkatkan kebolehbacaan.

Runnable r2 = () -> System.out.println("Hello world two!");

Menapis, Memetakan dan Mengumpul

API Strim membolehkan operasi dirantai bersama, membolehkan pembangun menapis, memetakan dan mengumpul hasil dalam satu kenyataan.

Contoh: Menapis dan Mengumpul:

Runnable r1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("Running with anonymous inner class");
    }
};
r1.run();

Kod ini menapis hanya lelaki berumur 18 hingga 25 tahun, menggunakan kriteria yang ditentukan dalam kelas SearchCriteria.

Pemetaan dan Transformasi dengan peta:
Kaedah peta mengubah setiap elemen dalam koleksi, seperti dengan mengekstrak atau mengubah suai sifat.

Runnable r2 = () -> System.out.println("Running with Lambda Expression");
r2.run();

Menggunakan peta untuk Pengiraan:
Kaedah mapToInt dan mapToDouble berguna untuk pengiraan berangka.

(parameters) -> expression
(parameters) -> { statements; }

Memahami Kemalasan dan Keghairahan dalam Aliran

Strim menyokong operasi malas dan bersemangat, dengan operasi malas (seperti penapis) hanya digunakan apabila diperlukan. Kemalasan ini mengoptimumkan prestasi dengan memproses elemen yang diperlukan sahaja.

1. Operasi Malas: Digunakan hanya apabila operasi terminal (seperti collect) dicapai.
2. Operasi Bersemangat: Dilaksanakan serta-merta pada semua elemen, biasanya digunakan untuk pengagregatan.

Contoh Penilaian Malas:

  (int x, int y) -> x + y

Hanya orang yang berumur lebih daripada 30 tahun diproses dan nama keluarga dicetak, menunjukkan penapisan malas.

Pemprosesan Selari dengan Strim

Kaedah parallelStream Java mengagihkan tugas merentas berbilang urutan, menawarkan keuntungan prestasi yang ketara untuk set data yang besar.

Contoh Aliran Selari:

  (String message) -> System.out.println(message)

Pemprosesan selari membahagikan beban kerja, menjadikan operasi pada koleksi lebih cepat untuk tugasan intensif pengiraan.

Mutasi dan Hasil Pengumpulan

Memandangkan strim sememangnya tidak boleh diubah, keputusan perlu dikumpul untuk mengekalkannya. Kaedah pengumpulan menyediakan cara untuk mengagregat dan mengekalkan hasil operasi strim.

Contoh:

Runnable r1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello world one!");
    }
};

Di sini, hasil yang ditapis disimpan dalam senarai untuk pemprosesan selanjutnya, membolehkan pembangun mengurus aliran data yang kompleks dengan cara berstruktur.

Kesimpulan: Kuasa Ungkapan Lambda dalam Java 8

Ekspresi Lambda Java 8, digandingkan dengan Stream API, mewakili anjakan besar ke arah pengaturcaraan berfungsi, menjadikan kod lebih ringkas, ekspresif dan boleh diselenggara. Dengan menggantikan kelas dalaman tanpa nama, meningkatkan pemprosesan koleksi dan menyokong operasi selari, Lambda Expressions telah menjadi asas untuk menulis aplikasi Java moden.

Sebarang pembetulan atau penambahan pada siaran ini dialu-alukan.

Terima kasih kerana membaca!

Runnable r2 = () -> System.out.println("Hello world two!");

Atas ialah kandungan terperinci Menguasai Ungkapan Lambda dalam Java Panduan Komprehensif. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!