Kuidas hakata Java-s töötama Lambda Expressionsiga

Enne kui JDK 8 lisas Lambda väljendite toe, kasutasin nende näiteid ainult sellistes keeltes nagu C # ja C ++.

Kui see funktsioon Java-sse lisati, hakkasin neid veidi lähemalt uurima.

Lambda-avaldiste lisamine lisab süntaksielemente, mis suurendavad Java väljendusjõudu. Selles artiklis tahan keskenduda fundamentaalsetele mõistetele, mida peate tundma õppima, et saaksite juba täna oma koodile lambda-väljendeid lisada.

Kiire sissejuhatus

Lambda avaldised kasutavad ära mitme tuumaga keskkondade paralleelseid protsessivõimalusi, mida näevad Stream API andmetega seotud gaasijuhtmete toimingute toel.

Need on anonüümsed meetodid (nimeta meetodid), mida kasutatakse funktsionaalse liidese määratletud meetodi rakendamiseks. Enne oma käte määrimist lambda-väljenditega on oluline teada, mis on funktsionaalne liides.

Funktsionaalne liides

Funktsionaalne liides on liides, mis sisaldab ühte ja ainult ühte abstraktset meetodit.

Kui te võtate pilk määratlus Java standard Runnable liides, märkad, kuidas see jaguneb mõiste funktsionaalne kasutajaliides, sest see määratleb ainult üks meetod: run().

Allolevas koodinäites on meetod computeNamevaikimisi abstraktne ja ainus määratletud meetod, mis muudab MyName'i funktsionaalseks liideseks.

interface MyName{ String computeName(String str); }

Nooleoperaator

Lambda väljendid tutvustavad ->Java-s uut nooleoperaatorit. See jagab lambda väljendid kaheks osaks:

(n) -> n*n

Vasak külg määrab avaldisega nõutavad parameetrid, mis võivad ka tühjad olla, kui parameetreid pole vaja.

Parem külg on lambda keha, mis määrab lambda avaldise toimingud. Võib olla kasulik mõelda sellele operaatorile kui "muutub". Näiteks "n saab n * n" või "n saab n ruutu".

Funktsionaalse liidese ja nooleoperaatori kontseptsioone silmas pidades saate kokku panna lihtsa lambda avaldise:

interface NumericTest { boolean computeTest(int n); } public static void main(String args[]) { NumericTest isEven = (n) -> (n % 2) == 0; NumericTest isNegative = (n) -> (n < 0); // Output: false System.out.println(isEven.computeTest(5)); // Output: true System.out.println(isNegative.computeTest(-5)); }
interface MyGreeting { String processName(String str); } public static void main(String args[]) { MyGreeting morningGreeting = (str) -> "Good Morning " + str + "!"; MyGreeting eveningGreeting = (str) -> "Good Evening " + str + "!"; // Output: Good Morning Luis! System.out.println(morningGreeting.processName("Luis")); // Output: Good Evening Jessica! System.out.println(eveningGreeting.processName("Jessica")); }

Eespool toodud valimi muutujad morningGreetingja eveningGreetingread 6 ja 7 viitavad MyGreetingliidesele ja määratlevad erinevad tervitusavaldised.

Lambda-avaldise kirjutamisel on avaldises võimalik ka parameetri tüüp selgesõnaliselt määrata:

MyGreeting morningGreeting = (String str) -> "Good Morning " + str + "!"; MyGreeting eveningGreeting = (String str) -> "Good Evening " + str + "!";

Blokeeri lambda väljendid

Siiani olen katnud ühe ekspressiooni lambdade proove. On veel ühte tüüpi väljendit, mida kasutatakse juhul, kui nooleoperaatori paremal küljel olev kood sisaldab rohkem kui ühte lauset, mida nimetatakse plokk-lambdaks :

interface MyString { String myStringFunction(String str); } public static void main (String args[]) { // Block lambda to reverse string MyString reverseStr = (str) -> { String result = ""; for(int i = str.length()-1; i >= 0; i--) result += str.charAt(i); return result; }; // Output: omeD adbmaL System.out.println(reverseStr.myStringFunction("Lambda Demo")); }

Üldised funktsionaalsed liidesed

Lambda väljend ei saa olla üldine. Kuid lambda-avaldisega seotud funktsionaalne liides saab. Võimalik on kirjutada üks üldine liides ja käsitseda erinevaid tagastustüüpe:

interface MyGeneric { T compute(T t); } public static void main(String args[]){ // String version of MyGenericInteface MyGeneric reverse = (str) -> { String result = ""; for(int i = str.length()-1; i >= 0; i--) result += str.charAt(i); return result; }; // Integer version of MyGeneric MyGeneric factorial = (Integer n) -> { int result = 1; for(int i=1; i <= n; i++) result = i * result; return result; }; // Output: omeD adbmaL System.out.println(reverse.compute("Lambda Demo")); // Output: 120 System.out.println(factorial.compute(5)); }

Lambda-väljendid kui argumendid

Üks lambdade tavaline kasutusviis on nende argumentidena edastamine.

Neid saab kasutada mis tahes kooditükis, mis pakub sihtmärgi tüüpi. Minu arvates on see põnev, kuna see võimaldab mul meetoditele argumentidena käivitatavat koodi edastada.

Lambda-väljendite edastamiseks parameetritena veenduge, et funktsionaalse liidese tüüp ühilduks vajaliku parameetriga.

interface MyString { String myStringFunction(String str); } public static String reverseStr(MyString reverse, String str){ return reverse.myStringFunction(str); } public static void main (String args[]) { // Block lambda to reverse string MyString reverse = (str) -> { String result = ""; for(int i = str.length()-1; i >= 0; i--) result += str.charAt(i); return result; }; // Output: omeD adbmaL System.out.println(reverseStr(reverse, "Lambda Demo")); }

Need mõisted annavad teile hea aluse lambda-väljenditega töötamise alustamiseks. Heitke pilk oma koodile ja vaadake, kus saate Java väljendusjõudu suurendada.