Dalam artikel ini, kita akan belajar tentang ekspresi lambda Java dan penggunaan ekspresi lambda dengan antara muka fungsional, antara muka fungsional generik, dan streaming API dengan bantuan contoh.
Ungkapan lambda diperkenalkan pertama kali di Java 8. Objektif utamanya untuk meningkatkan kekuatan ekspresif bahasa.
Tetapi, sebelum masuk ke lambdas, pertama-tama kita perlu memahami antara muka yang berfungsi.
Apa itu antara muka fungsional?
Sekiranya antara muka Java mengandungi satu dan satu kaedah abstrak maka ia disebut sebagai antara muka fungsional. Satu-satunya kaedah ini menentukan tujuan antara muka yang dimaksudkan.
Contohnya, Runnableantara muka dari pakej java.lang; adalah antara muka yang berfungsi kerana hanya merupakan satu kaedah iaitu run().
Contoh 1: Tentukan Antaramuka Berfungsi dalam java
import java.lang.FunctionalInterface; @FunctionalInterface public interface MyInterface( // the single abstract method double getValue(); )
Dalam contoh di atas, antara muka MyInterface hanya mempunyai satu kaedah abstrak getValue (). Oleh itu, ia adalah antara muka yang berfungsi.
Di sini, kami telah menggunakan anotasi @FunctionalInterface. Anotasi memaksa penyusun Java untuk menunjukkan bahawa antara muka adalah antara muka yang berfungsi. Oleh itu, tidak membenarkan mempunyai lebih daripada satu kaedah abstrak. Walau bagaimanapun, ia tidak wajib.
Di Java 7, antara muka fungsional dianggap sebagai Kaedah Abstrak Tunggal atau jenis SAM . SAM biasanya dilaksanakan dengan Kelas Tanpa Nama di Java 7.
Contoh 2: Laksanakan SAM dengan kelas tanpa nama di java
public class FunctionInterfaceTest ( public static void main(String() args) ( // anonymous class new Thread(new Runnable() ( @Override public void run() ( System.out.println("I just implemented the Runnable Functional Interface."); ) )).start(); ) )
Keluaran :
Saya baru melaksanakan Runnable Functional Interface.
Di sini, kita boleh lulus kelas tanpa nama kepada kaedah. Ini membantu menulis program dengan lebih sedikit kod di Java 7. Walau bagaimanapun, sintaksnya masih sukar dan banyak baris kod tambahan diperlukan.
Java 8 memperluas kekuatan SAM dengan melangkah lebih jauh. Oleh kerana kita tahu bahawa antara muka fungsional hanya mempunyai satu kaedah, tidak perlu menentukan nama kaedah itu ketika meneruskannya sebagai argumen. Ekspresi lambda membolehkan kita melakukan perkara yang tepat.
Pengenalan ungkapan lambda
Ekspresi lambda, pada dasarnya, adalah kaedah tanpa nama atau tanpa nama. Ungkapan lambda tidak dapat dilaksanakan dengan sendirinya. Sebaliknya, ia digunakan untuk menerapkan kaedah yang ditentukan oleh antara muka fungsional.
Bagaimana cara menentukan ungkapan lambda di Java?
Inilah cara kita dapat menentukan ungkapan lambda di Java.
(parameter list) -> lambda body
Operator baru ( ->) yang digunakan dikenali sebagai operator anak panah atau pengendali lambda. Sintaks mungkin tidak jelas buat masa ini. Mari kita terokai beberapa contoh,
Katakan, kami mempunyai kaedah seperti ini:
double getPiValue() ( return 3.1415; )
Kita boleh menulis kaedah ini menggunakan ungkapan lambda sebagai:
() -> 3.1415
Di sini, kaedah ini tidak mempunyai parameter. Oleh itu, bahagian kiri operator merangkumi parameter kosong. Bahagian kanan adalah badan lambda yang menentukan tindakan ungkapan lambda. Dalam kes ini, ia mengembalikan nilai 3.1415.
Jenis-jenis Badan Lambda
Di Jawa, badan lambda terdiri daripada dua jenis.
1. Badan dengan ungkapan tunggal
() -> System.out.println("Lambdas are great");
Badan lambda jenis ini dikenali sebagai badan ekspresi.
2. Badan yang terdiri daripada blok kod.
() -> ( double pi = 3.1415; return pi; );
Badan lambda jenis ini dikenali sebagai badan blok. Badan blok membolehkan badan lambda memasukkan beberapa pernyataan. Pernyataan-pernyataan ini dilampirkan di dalam pendakap dan anda harus menambahkan titik koma selepas pendakap.
Catatan : Untuk isi blok, anda boleh mempunyai penyata pengembalian jika isi mengembalikan nilai. Walau bagaimanapun, badan ekspresi tidak memerlukan penyataan pengembalian.
Contoh 3: Ungkapan Lambda
Mari tulis program Java yang mengembalikan nilai Pi menggunakan ungkapan lambda.
Seperti disebutkan sebelumnya, ungkapan lambda tidak dilaksanakan dengan sendirinya. Sebaliknya, ia membentuk pelaksanaan kaedah abstrak yang ditentukan oleh antara muka fungsional.
Oleh itu, kita perlu menentukan antara muka berfungsi terlebih dahulu.
import java.lang.FunctionalInterface; // this is functional interface @FunctionalInterface interface MyInterface( // abstract method double getPiValue(); ) public class Main ( public static void main( String() args ) ( // declare a reference to MyInterface MyInterface ref; // lambda expression ref = () -> 3.1415; System.out.println("Value of Pi = " + ref.getPiValue()); ) )
Keluaran :
Nilai Pi = 3.1415
Dalam contoh di atas,
- Kami telah membuat antara muka berfungsi bernama MyInterface. Ia mengandungi satu kaedah abstrak bernama
getPiValue() - Di dalam kelas Utama, kami telah menyatakan rujukan ke MyInterface. Perhatikan bahawa kita dapat menyatakan rujukan antara muka tetapi kita tidak dapat membuat contoh antara muka. Itu dia,
// it will throw an error MyInterface ref = new myInterface(); // it is valid MyInterface ref; - Kami kemudian menetapkan ungkapan lambda sebagai rujukan.
ref = () -> 3.1415; - Akhirnya, kami memanggil kaedah
getPiValue()menggunakan antara muka rujukan. Bila
System.out.println("Value of Pi = " + ref.getPiValue());
Ekspresi Lambda dengan parameter
Hingga kini kami telah membuat ungkapan lambda tanpa parameter. Namun, serupa dengan kaedah, ungkapan lambda juga boleh mempunyai parameter. Sebagai contoh,
(n) -> (n%2)==0
Here, the variable n inside the parenthesis is a parameter passed to the lambda expression. The lambda body takes the parameter and checks if it is even or odd.
Example 4: Using lambda expression with parameters
@FunctionalInterface interface MyInterface ( // abstract method String reverse(String n); ) public class Main ( public static void main( String() args ) ( // declare a reference to MyInterface // assign a lambda expression to the reference MyInterface ref = (str) -> ( String result = ""; for (int i = str.length()-1; i>= 0 ; i--) result += str.charAt(i); return result; ); // call the method of the interface System.out.println("Lambda reversed = " + ref.reverse("Lambda")); ) )
Output:
Lambda reversed = adbmaL
Generic Functional Interface
Till now we have used the functional interface that accepts only one type of value. For example,
@FunctionalInterface interface MyInterface ( String reverseString(String n); )
The above functional interface only accepts String and returns String. However, we can make the functional interface generic, so that any data type is accepted. If you are not sure about generics, visit Java Generics.
Example 5: Generic Functional Interface and Lambda Expressions
// GenericInterface.java @FunctionalInterface interface GenericInterface ( // generic method T func(T t); ) // GenericLambda.java public class Main ( public static void main( String() args ) ( // declare a reference to GenericInterface // the GenericInterface operates on String data // assign a lambda expression to it GenericInterface reverse = (str) -> ( String result = ""; for (int i = str.length()-1; i>= 0 ; i--) result += str.charAt(i); return result; ); System.out.println("Lambda reversed = " + reverse.func("Lambda")); // declare another reference to GenericInterface // the GenericInterface operates on Integer data // assign a lambda expression to it GenericInterface factorial = (n) -> ( int result = 1; for (int i = 1; i <= n; i++) result = i * result; return result; ); System.out.println("factorial of 5 = " + factorial.func(5)); ) )
Output:
Lambda reversed = adbmaL factorial of 5 = 120
In the above example, we have created a generic functional interface named GenericInterface. It contains a generic method named func().
Here, inside the Main class,
GenericInterface reverse- creates a reference to the interface. The interface now operates onStringtype of data.GenericInterface factorial- creates a reference to the interface. The interface, in this case, operates on theIntegertype of data.
Lambda Expression and Stream API
The new java.util.stream package has been added to JDK8 which allows java developers to perform operations like search, filter, map, reduce, or manipulate collections like Lists.
For example, we have a stream of data (in our case a List of String) where each string is a combination of country name and place of the country. Now, we can process this stream of data and retrieve only the places from Nepal.
For this, we can perform bulk operations in the stream by the combination of Stream API and Lambda expression.
Example 6: Demonstration of using lambdas with the Stream API
import java.util.ArrayList; import java.util.List; public class StreamMain ( // create an object of list using ArrayList static List places = new ArrayList(); // preparing our data public static List getPlaces()( // add places and country to the list places.add("Nepal, Kathmandu"); places.add("Nepal, Pokhara"); places.add("India, Delhi"); places.add("USA, New York"); places.add("Africa, Nigeria"); return places; ) public static void main( String() args ) ( List myPlaces = getPlaces(); System.out.println("Places from Nepal:"); // Filter places from Nepal myPlaces.stream() .filter((p) -> p.startsWith("Nepal")) .map((p) -> p.toUpperCase()) .sorted() .forEach((p) -> System.out.println(p)); ) )
Output:
Places from Nepal: NEPAL, KATHMANDU NEPAL, POKHARA
In the above example, notice the statement,
myPlaces.stream() .filter((p) -> p.startsWith("Nepal")) .map((p) -> p.toUpperCase()) .sorted() .forEach((p) -> System.out.println(p));
Here, we are using the methods like filter(), map() and forEach() of the Stream API. These methods can take a lambda expression as input.
Kita juga dapat menentukan ungkapan kita sendiri berdasarkan sintaks yang kita pelajari di atas. Ini membolehkan kita mengurangkan garis kod secara drastik seperti yang kita lihat dalam contoh di atas.
