Advertentie
Als je een Java-programmeur bent en meer wilt weten over Java 8 lambdas, gaan we in dit artikel de lambda-syntaxis en het gebruik nader bekijken.
EEN lambda-uitdrukking 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 hoofdtekst. Het lichaam kan een single zijn expressie of een blok 10 basis Java-concepten die u moet leren wanneer u aan de slag gaatOf u nu een GUI schrijft, serversoftware ontwikkelt of een mobiele applicatie gebruikt met Android, Java leren zal u goed van pas komen. Hier zijn enkele basis Java-concepten om u op weg te helpen. Lees verder . Het wordt vaak gebruikt wanneer een implementatie van een interface vereist is. Deze behoefte ontstaat meestal wanneer een interface nodig is als argument om een methode aan te roepen.
Enkele eenvoudige Lambda-uitdrukkingen
Laten we eens kijken naar enkele eenvoudige voorbeelden van lambda-uitdrukkingen.
Het volgende is een lambda-uitdrukking die twee getallen accepteert X en y en berekent de som.
(int x, int y) -> x + y; Zet de parametertypen neer voor een beknoptere weergave:
(x, y) -> x + y; Definieer een functie die geen parameters accepteert:
() -> 404; Het volgende is ook geldig, dat geen parameters accepteert en niets retourneert:
() -> {}
Geen haakjes nodig die parameters bevatten voor een enkele parameter:
x -> x + 1. Ook complexere codeblokken zijn mogelijk. De volgende lambda accepteert een single lijn parameter en verwerkt het. Merk op dat het type van de parameter wordt afgeleid uit de omringende context:
lijn -> { String [] x = pattern.split (lijn); retourneer 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 uw code schoon en beknopt te maken. Om hierbij te helpen, maken Java 8-klassen uitgebreid gebruik van lambdas.
Looping over een lijst of een set
Collectieklassen zoals Lijst, Stel, Wachtrij, en implementeren de Iterabel interface die het doorlopen van de elementen veel gemakkelijker maakt.
Verklaar een lijst met namen.
Lijst names = Arrays.asList ("Joe", "Jack", "James", "Albert"); Loop over de lijst zonder lambda:
voor (String name: names) {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); Looping over een kaart
EEN Kaart is een toewijzing van sleutels tot waarden. Looping over een kaart houdt in dat u een lus maakt over elk van de (key, value) mapping. Vergelijk hoe je lambdas kunt gebruiken voor deze situatie.
Definieer eerst een kaart:
Kaart map = 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 (Kaart. Binnenkomst e: map.entrySet ()) {System.out.println (e.getKey () + "=>" + e.getValue ()); }
Hier ziet u hoe u snel en beknopt hetzelfde kunt doen met lambdas:
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 a functionele interface - een interface met een enkele abstracte methode. U kunt een lambda-expressie toewijzen aan een interface met een compatibele abstracte methode. Enkele voorbeelden hieronder.
Een multi-threaded taak maken
Overweeg om een taak voor te maken uitvoering in een aparte thread 4 methoden voor het schrijven van multi-threaded code in JavaIn dit artikel vergelijken we een aantal opties voor het schrijven van multi-threaded code in Java, zodat je beter kunt beoordelen welke optie je moet gebruiken voor je volgende Java-project. Lees verder - u moet de taak definiëren als een Uitvoerbaar interface en implementeer de rennen() methode. Hier Uitvoerbaar is een functionele interface.
klasse MyTask implementeert Runnable {... public void run () {// implementeer je taak hier System.out.println ("Wordt nu in een aparte thread uitgevoerd."); }... }
Vervolgens kunt u 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 = nieuwe thread (taak); thread.start (); Met behulp van een lambda, het proces van het creëren van een Uitvoerbaar wordt veel gemakkelijker. Bovenstaande taakdefinitie kan worden herschreven als:
Uitvoerbare taak = () -> System.out.println ("Wordt nu in een aparte thread uitgevoerd."); Of zelfs:
Thread thread = nieuwe thread (() -> System.out.println ("Wordt nu in een aparte thread uitgevoerd.")); thread.start (); Vergelijking met behulp van een vergelijker
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 Comparator gebruikt om tekenreeksen ongevoelig te vergelijken.
Comparator cmp = (x, y) -> x.compareToIgnoreCase (y); Ooit een exemplaar van de Comparator Er is een functionele interface gemaakt, deze kan indien nodig 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 doorzoeken met de Binaire zoekopdracht() methode als volgt:
System.out.println ("search (Joe):" + Collections.binarySearch (namen, "Joe", cmp)); # afdrukken. zoeken (Joe): 3. Het berekenen van maximum en minimum uit een lijst is ook eenvoudig met lambdas.
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 print het maximum en minimum:
System.out.println ("Max / Min"); System.out.println (Collections.max (temps, cmpTemp) + "/" + Collections.min (temps, cmpTemp)); Gebruik in GUI-programmering
Lambda-expressies zijn ook uitermate handig in GUI-programmering om event handlers te implementeren. Hier is een voorbeeld van het gebruik van een knopklikhandler.
JButton-knop = nieuwe JButton ("Click Me"); button.addActionListener (e -> System.out.println ("knop aangeklikt!")); En dat was een snelle blik op het gebruik van lambdas in Java 8.
Hebben lambdas uw leven sinds Java 8 gemakkelijker gemaakt? Leg dit uit in de onderstaande opmerkingen.
