Bagaimana saya menggunakan java lambdas dan antara muka berfungsi?

Artikel ini menerangkan Java Lambdas -Concise Functions Anonymous -dan penggunaannya dengan antara muka berfungsi (antara muka dengan satu kaedah abstrak). Ia memperincikan sintaks lambda, membezakannya dengan kelas dalaman tanpa nama yang menonjolkan keringkasan dan kebolehbacaan

Cara Menggunakan Java Lambdas dan Antara muka Fungsional

Java Lambdas adalah ringkas, fungsi tanpa nama yang menyediakan paradigma pengaturcaraan berfungsi dalam Java. Mereka pada dasarnya blok kod yang boleh diluluskan sebagai hujah kepada kaedah atau disimpan dalam pembolehubah. Untuk menggunakannya, anda memerlukan antara muka berfungsi , yang merupakan antara muka dengan satu kaedah abstrak yang tepat (walaupun ia boleh mempunyai beberapa kaedah lalai atau kaedah statik). Tandatangan ekspresi Lambda secara tersirat sepadan dengan kaedah abstrak antara muka berfungsi.

Berikut adalah contoh mudah menggunakan antara muka Runnable (antara muka fungsional terbina dalam):

 <code class="java">Runnable myRunnable = () -> System.out.println("Hello from a lambda!"); new Thread(myRunnable).start();</code>

Kod ini mencipta ungkapan lambda () -> System.out.println("Hello from a lambda!"); Itu melaksanakan kaedah run() antara muka Runnable . Pandangan kosong () menunjukkan bahawa lambda tidak mengambil argumen. Anak panah -> memisahkan senarai parameter dari badan.

Satu lagi contoh menggunakan lambda dengan parameter:

 <code class="java">interface StringOperation { String operate(String str); } StringOperation reverseString = (str) -> new StringBuilder(str).reverse().toString(); String reversed = reverseString.operate("hello"); // reversed will be "olleh"</code>

Di sini, StringOperation adalah antara muka berfungsi. Ekspresi Lambda (str) -> new StringBuilder(str).reverse().toString() mengambil argumen String ( str ) dan mengembalikan String terbalik.

Manfaat Lambdas Java melalui Kelas Dalam Tanpa Nama

Kelas dalaman tanpa nama, sambil mencapai fungsi yang sama, jauh lebih jelas daripada lambdas. Menggunakan Lambdas menawarkan beberapa kelebihan utama:

• Brevity: Lambdas lebih ringkas, membawa kepada kod yang lebih bersih dan lebih mudah dibaca. Ini mengurangkan jumlah kod boilerplate yang diperlukan.
• Pembacaan yang lebih baik: Sintaks ringkas Lambdas menjadikan kod lebih mudah difahami dan diselenggara. Logik teras adalah jelas, tidak seperti kelas dalaman tanpa nama di mana sintaks dapat mengaburkan niat.
• Fleksibiliti yang dipertingkatkan: Lambdas boleh digunakan lebih fleksibel dalam pelbagai konteks, seperti argumen kaedah, nilai pulangan, dan tugasan yang berubah -ubah. Kelas dalaman tanpa nama lebih terhad dalam penggunaannya.
• Jenis Kesimpulan: Penyusun menanggung jenis parameter lambda, mengurangkan keperluan pengisytiharan jenis eksplisit. Ini memudahkan kod dan menjadikannya kurang terdedah kepada kesilapan.

Pertimbangkan contoh Runnable sekali lagi. Setaraf kelas dalaman tanpa nama akan menjadi:

 <code class="java">Runnable myRunnable = new Runnable() { @Override public void run() { System.out.println("Hello from an anonymous inner class!"); } }; new Thread(myRunnable).start();</code>

Ini jelas lebih panjang dan kurang ekspresif daripada versi Lambda.

Membuat antara muka berfungsi anda sendiri di Java

Mewujudkan antara muka fungsional anda sendiri adalah mudah. Cukup tentukan antara muka dengan satu kaedah abstrak yang tepat. Anda boleh menambah kaedah lalai dan kaedah statik seperti yang diperlukan. Anotasi @FunctionalInterface adalah pilihan tetapi disyorkan. Ia membantu pengkompil menguatkuasakan peraturan kaedah abstrak tunggal dan menangkap kesilapan awal.

 <code class="java">@FunctionalInterface interface MyFunctionalInterface { int calculate(int a, int b); default int add(int a, int b){ return ab; } } // Usage MyFunctionalInterface myOperation = (a, b) -> a * b; int result = myOperation.calculate(5, 3); // result will be 15 int sum = myOperation.add(5,3); // result will be 8</code>

Dalam contoh ini, MyFunctionalInterface adalah antara muka berfungsi dengan satu kaedah abstrak calculate() . Anotasi @FunctionalInterface menunjukkan ini. Kaedah add() adalah kaedah lalai.

Menggunakan Lambdas Java dengan Perpustakaan dan Rangka Kerja yang sedia ada

Java Lambdas disokong secara meluas oleh banyak perpustakaan dan kerangka Java yang ada. Mereka disatukan ke dalam API Java Teras dan biasanya digunakan dengan:

• Java Streams API: API Streams sangat bergantung pada lambdas untuk memproses koleksi data dengan cekap.
• Swing dan Javafx: Pengendalian acara dalam kerangka UI ini dapat dipermudahkan dengan ketara menggunakan lambdas.
• Rangka Kerja Spring: Spring secara meluas menggunakan lambdas untuk suntikan ketergantungan, pengendalian acara, dan aspek lain.
• Banyak perpustakaan lain: banyak perpustakaan pihak ketiga menggabungkan lambdas ke dalam API mereka untuk kod yang lebih ringkas dan berfungsi.

Sebagai contoh, menggunakan Lambdas dengan API Streams:

 <code class="java">List<integer> numbers = Arrays.asList(1, 2, 3, 4, 5); int sum = numbers.stream().map(n -> n * 2).sum(); // sum will be 30</integer></code>

Kod ini menggunakan lambda n -> n * 2 dalam saluran paip aliran untuk menggandakan setiap nombor sebelum menjumlahkannya. Ini adalah pendekatan yang lebih bersih berbanding menggunakan lelaran tradisional. Penggunaan lambdas yang meluas menjadikan mereka sebahagian penting dalam pembangunan Java moden.

Atas ialah kandungan terperinci Bagaimana saya menggunakan java lambdas dan antara muka berfungsi?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!