Een snelle inleiding tot Java 8 Lambda's

Als je een Java-programmeur bent en geïnteresseerd bent in meer informatie over Java 8 lambda's, gaan we in dit artikel de lambda-syntaxis en gebruik nader bekijken.

EEN lambda-expressie in Java is een beknopte manier om een ​​methode van een klasse in een uitdrukking uit te drukken. Het heeft een lijst met parameters en een lichaam. Het lichaam kan een enkele expressie of een blok zijn. 10 Kern Java-concepten die u moet leren bij het begin 10 Kern Java-concepten die u moet leren wanneer u aan de slag gaat Of u nu een GUI schrijft, software aan de server ontwikkelt of een mobiele applicatie met Android gebruikt Java leren zal je goed van pas komen. Hier zijn enkele kern-Java-concepten om u te helpen aan de slag te gaan. Lees verder . Het wordt vaak gebruikt waar een implementatie van een interface vereist is. Deze behoefte ontstaat meestal wanneer een interface vereist is als argument om een ​​methode aan te roepen.

Enkele eenvoudige Lambda-expressies

Laten we eens kijken naar enkele eenvoudige voorbeelden van lambda-expressies.

Het volgende is een lambda-uitdrukking die twee getallen accepteert X en Y en berekent de som.

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

Drop de parameter types voor een meer beknopte weergave:

(x, y) -> x + y; 

Definieer een functie die geen parameters accepteert:

() -> 404; 

Het volgende is ook geldig, die geen parameters accepteert en niets teruggeeft:

() ->  

Geen parantheses nodig die parameters voor één enkele parameter omsluiten:

x -> x + 1 

Meer complexe codeblokken zijn ook mogelijk. De volgende lambda accepteert een single lijn parameter en verwerkt het. Merk op dat het type parameter wordt afgeleid uit de omringende context:

regel -> String [] x = pattern.split (regel); keer terug naar de nieuwe speler (Integer.parseInt (x [0]), x [1], x [2], x [3], Integer.parseInt (x [4]));  

Schone en beknopte codering

Het gebruik van lambda-expressies helpt je code schoon en beknopt te maken. Om hieraan te helpen maken Java 8-klassen uitgebreid gebruik van lambda's.

Looping over een lijst of een set

Collectieklassen zoals Lijst, set, Wachtrij, en dergelijke implementeren de Iterable interface die het lussen over de elementen veel eenvoudiger maakt.

Declareer een lijst met namen.

Lijst names = Arrays.asList ("Joe", "Jack", "James", "Albert"); 

Loop over de lijst zonder lambda:

for (String naam: namen) System.out.println (name);  

Met lambda kan de bovenstaande lus worden geschreven als:

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

Met Java 8-methodeverwijzingen kan het bovenstaande nog beknopter worden geschreven als:

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

Over een kaart lus

EEN Kaart is een toewijzing van sleutels tot waarden. Een lus over een kaart impliceert een lus over elk van de (sleutel, waarde) toewijzing. Vergelijk hoe je lambda's kunt gebruiken voor deze situtatie.

Definieer eerst een kaart:

Kaart kaart = nieuwe 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); 

U kunt deze kaart op de traditionele manier doorlopen:

voor (Map.Entry e: map.entrySet ()) System.out.println (e.getKey () + "=>" + e.getValue ());  

Hier is hoe je hetzelfde kunt doen op een snelle en beknopte manier met lambda's:

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

Functionele interfaces

Wat is het retourtype van een lambda-expressie? Met andere woorden, wat is het type X in de volgende verklaring?

X x = a -> a + 1; 

Het retourtype van een lambda-expressie is een functionele interface - een interface met een enkele abstracte methode. U kunt een lambda-uitdrukking toewijzen aan een interface met een compatibele abstracte methode. Enkele voorbeelden hieronder.

Een multi-threaded taak maken

Overweeg een taak voor uitvoering in een afzonderlijke thread te maken 4 Methoden voor het schrijven van code met meerdere threads in Java 4 Methoden voor het schrijven van code met meerdere threads in Java In dit artikel vergelijken we enkele opties voor het schrijven van code met meerdere threads in Java, dus u kunt beter beoordelen welke optie u wilt gebruiken voor uw volgende Java-project. Lees meer - u moet de taak definiëren als een uitvoerbare interface en implementeer de rennen() methode. Hier uitvoerbare is een functionele interface.

class MyTask implementeert Runnable ... public void run () // implementeer uw taak hier System.out.println ("Nu in een afzonderlijke thread.");  ... 

U kunt dan een exemplaar van de maken Mijn taak klasse en gebruik deze om een ​​nieuwe thread van uitvoering te starten.

MyTask-taak = nieuwe MyTask (); Thread thread = new Thread (task); thread.start (); 

Met behulp van een lambda, het proces van het creëren van een uitvoerbare wordt veel gemakkelijker. De taakdefinitie hierboven kan worden herschreven als:

Runnable task = () -> System.out.println ("Nu in een aparte thread uitgevoerd."); 

Of zelfs:

Discussie thread = new Thread (() -> System.out.println ("Nu in een aparte thread.")); thread.start (); 

Vergelijking met behulp van een comparator

De Comparator is een functionele interface voor het vergelijken van objecten van een bepaald type. Het definieert een enkele abstracte methode genaamd vergelijken() die kan worden gedefinieerd met behulp van een lambda-expressie.

Hier is een lambda-uitdrukking die een creëert Comparator gebruikt om strings case-insensitively te vergelijken.

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

Eens een instantie van de Comparator functionele interface is gemaakt, deze kan naar behoefte opnieuw worden gebruikt.

Hier sorteren we een lijst met strings in oplopende volgorde.

Lijst names = Arrays.asList ("Joe", "Jack", "James", "Albert"); Collections.sort (namen, cmp); names.forEach (System.out :: println); // prints Albert Jack James Joe 

De bovenstaande lijst is op zijn plaats gesorteerd. We kunnen het nu zoeken met behulp van de Binaire zoekopdracht() methode als volgt:

System.out.println ("search (Joe):" + Collections.binarySearch (namen, "Joe", cmp)); # prints zoeken (Joe): 3 

Het berekenen van maximum en minimum uit een lijst is ook eenvoudig met lambda's.

Bepaal enkele gegevens:

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

Gebruik een lambda-uitdrukking om de comparator te definiëren:

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

En druk het maximum en minimum af:

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

Gebruik in GUI-programmering

Lambda-expressies zijn ook uiterst nuttig bij het programmeren van GUI om gebeurtenishandlers te implementeren. Hier is een voorbeeld van het gebruik van een knopklikbehandelaar.

JButton-knop = nieuwe JButton ("Click Me"); button.addActionListener (e -> System.out.println ("Button clicked!")); 

En dat was een snelle blik op het gebruik van lambda's in Java 8.

Hebben lambda's je leven gemakkelijker gemaakt sinds Java 8? Gelieve uit te leggen in de opmerkingen hieronder.

Ontdek meer over: Java.