Annons

Om du är en Java-programmerare och är intresserad av att lära dig mer om Java 8 lambdas kommer vi i den här artikeln att titta närmare på lambdasyntax och användning.

EN lambda uttryck i Java är ett kortfattat sätt att uttrycka en metod för en klass i ett uttryck. Den har en lista över parametrar och ett organ. Kroppen kan vara en enda uttryck eller ett block 10 Core Java-koncept som du bör lära dig när du kommer igångOavsett om du skriver ett GUI, utvecklar serversidan mjukvara eller en mobil applikation med Android, kommer att lära sig Java tjäna dig bra. Här är några grundläggande Java-koncept som hjälper dig komma igång. Läs mer . Det används ofta där en implementering av ett gränssnitt krävs. Detta behov uppstår vanligtvis när ett gränssnitt krävs som argument för att åberopa en metod.

Några enkla Lambda-uttryck

Låt oss titta på några enkla exempel på lambda-uttryck.

Följande är ett lambda-uttryck som accepterar två siffror x och y och beräknar summan.

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

Släpp parametertyperna för en mer kortfattad representation:

instagram viewer 
(x, y) -> x + y;

Definiera en funktion som inte accepterar några parametrar:

() -> 404;

Följande är också giltig, som inte accepterar några parametrar och returnerar ingenting:

() -> {}

Inget behov av paranteser som bifogar parametrar för en enda parameter:

x -> x + 1.

Mer komplexa kodblock är också möjliga. Följande lambda accepterar en singel linje parameter och gör en del bearbetning på den. Observera att parametertypen härleds från det omgivande sammanhanget:

linje -> { String [] x = pattern.split (linje); returnera ny spelare (Integer.parseInt (x [0]), x [1], x [2], x [3], Integer.parseInt (x [4])); }

Ren och kortfattad kodning

Att använda lambda-uttryck hjälper dig att göra din kod ren och kortfattad. För att hjälpa till med detta använder Java 8-klasser en omfattande användning av lambdas.

Looping över en lista eller en uppsättning

Samlingskurser som Lista, Uppsättning, Köoch sådant implementerar Iterable gränssnitt som gör looping över elementen mycket enklare.

Förklara en lista med namn.

Lista namn = Arrays.asList ("Joe", "Jack", "James", "Albert");

Slinga över listan utan lambda:

för (String name: names) {System.out.println (name); }

Med hjälp av lambda kan ovanstående slinga skrivas som:

names.forEach (name -> System.out.println (name));

Med Java 8-metodreferenser kan ovanstående skrivas ännu mer kortfattat som:

names.forEach (System.out:: println);

Looping över en karta

EN Karta är en kartläggning av nycklar till värden. Looping över en karta innebär looping över var och en av (nyckel, värde) kartläggningen. Jämför hur du kan använda lambdas för den här situtationen.

Definiera först en karta:

Karta karta = ny HashMap <> (); map.put ("Atlanta, Georgia", 110); map.put ("Austin, Texas", 115); map.put ("Baltimore, Maryland", 105); map.put ("Birmingham, Alabama", 99); map.put ("Boston, Massachusetts", 98);

Du kan slinga över den här kartan på det traditionella sättet:

för (Karta. Inträde e: map.entrySet ()) {System.out.println (e.getKey () + "=>" + e.getValue ()); }

Så här kan du göra samma sak på ett snabbt och kortfattat sätt med lambdas:

map.forEach ((k, v) -> System.out.println (k + "=>" + v));

Funktionella gränssnitt

Vad är returtypen för ett lambda-uttryck? Med andra ord, vilken typ av X i följande uttalande?

X x = a -> a + 1;

Returtypen för ett lambda-uttryck är en funktionellt gränssnitt - ett gränssnitt med en enda abstrakt metod. Du kan tilldela ett lambda-uttryck till ett gränssnitt med en kompatibel abstrakt metod. Några exempel nedan.

Skapa en multi-gängad uppgift

Överväg att skapa en uppgift för exekvering i en separat tråd 4 Metoder för att skriva flera trådkoder i JavaI den här artikeln jämför vi några alternativ för att skriva multigängad kod i Java, så att du bättre kan bedöma vilket alternativ du ska använda för ditt nästa Java-projekt. Läs mer - du måste definiera uppgiften som en Runnable gränssnitt och implementera springa() metod. Här Runnable är ett funktionellt gränssnitt.

klass MyTask implementerar Runnable {... public void run () {// implementera din uppgift här System.out.println ("Kör i en separat tråd nu."); }... }

Du kan sedan skapa en instans av Min uppgift klass och använda den för att starta en ny tråd för körning.

MyTask-uppgift = ny MyTask (); Trådtråd = ny tråd (uppgift); thread.start ();

Med hjälp av en lambda är processen att skapa en Runnable blir mycket lättare. Uppgiftsdefinitionen ovan kan skrivas om som:

Runnable task = () -> System.out.println ("Kör i en separat tråd nu.");

Eller ens:

Trådtråd = ny tråd (() -> System.out.println ("Kör i en separat tråd nu.")); thread.start ();

Jämförelse med hjälp av en komparator

De Comparator är ett funktionellt gränssnitt för att jämföra objekt av en viss typ. Den definierar en enda abstrakt metod som kallas jämföra() som kan definieras med hjälp av ett lambda-uttryck.

Här är ett lambda-uttryck som skapar en Comparator används för att jämföra strängar från fall till känslor.

Comparator cmp = (x, y) -> x.compareToIgnoreCase (y);

En gång en instans av Comparator funktionellt gränssnitt har skapats, det kan användas om det behövs.

Här sorterar vi en lista med strängar i stigande ordning.

Lista namn = Arrays.asList ("Joe", "Jack", "James", "Albert"); Collections.sort (namn, cmp); names.forEach (System.out:: println); // utskrifter. Albert. Jack. James. Joe.

Listan ovan är sorterad på plats. Vi kan nu söka i det med hjälp av binarySearch () metod enligt följande:

System.out.println ("search (Joe):" + Collections.binarySearch (namn, "Joe", cmp)); # utskrifter. sök (Joe): 3.

Att beräkna maximalt och minimum från en lista är också enkelt att använda lambdas.

Definiera vissa data:

Lista temps = Arrays.asList (110, 115, 105, 99, 98, 54, 109, 84, 81, 66, 72, 135, 115, 75, 82, 90, 88);

Använd ett lambda-uttryck för att definiera komparatorn:

Comparator cmpTemp = (x, y) -> Integer.com-par (x, y);

Och skriv ut det maximala och det minsta:

System.out.println ("Max / Min"); System.out.println (Collections.max (temps, cmpTemp) + "/" + Collections.min (temps, cmpTemp));

Använd i GUI-programmering

Lambda-uttryck är också oerhört användbara i GUI-programmering för att implementera evenemangshanterare. Här är ett exempel på att använda en knappklickhanterare.

JButton-knapp = ny JButton ("Click Me"); button.addActionListener (e -> System.out.println ("Knappen klickade!"));

Och det var en snabb titt på att använda lambdas i Java 8.

Har lambdas gjort ditt liv enklare sedan Java 8? Förklara i kommentarerna nedan.