Ich werde den Syntax -Teil nicht schreiben. Lassen Sie uns einfach eine praktische Frage aufwerfen, um zu sehen, welche Annehmlichkeiten diese neuen Funktionen von Java8 zu uns bringen können.
Übrigens, eine generische Programmierung wird verwendet, alles dient dazu, den Code zu vereinfachen
Szene:
Eine Datenklasse, die Mitarbeiterinformationen aufzeichnet
public class Angestellter {public String Name; öffentliches int Alter; öffentlicher Char -Sex; öffentliche Stringzeit; öffentliches Int -Gehalt;}Wir haben eine Spalte dieser Art von Daten
LIST <Speore> Data = Arrays.aslist (E1, E2, E3 ......)
Es besteht jetzt ein Bedarf: Mitarbeiter von Gruppenangestellten nach dem ersten Brief ihrer Namen (vorausgesetzt, es handelt sich um alle englischen Namen):
Dann sollte das Ergebnis Map：char -> List<Employee> wir erzielen möchten
public static map <Zeichen <Zeichen, Liste <Mitarbeiter >> GroupByFirstChar (Liste <Personal> Daten) {map <Zeichen, Liste <Mitarbeiter >> result = new HashMap <> (); für (Mitarbeiter e: Daten) {Zeichen c = e.name.charat (0); Liste <Wepodee> l = result.get (c); if (l == null) {l = new ArrayList <> (); result.put (c, l); } l.add (e); } Rückgabeergebnis;}Der Code ist nicht kompliziert und kann bald abgeschlossen werden. Der Chef sieht, dass Sie so effizient sind, also sagte er, dass Sie es nach Ihrem Gehalt in Gruppen einteilen, für diejenigen unter 5.000, 5.000 ~ 10.000 ... usw.
Es wird nicht zu schwierig sein, ändern Sie einfach den Schlüssel und verarbeiten Sie es logisch ein wenig
public static map <String, Liste <Mitarbeiter >> GroupBySalary (Liste <Personal> Daten) {Map <String, Liste <Mitarbeiter >> result = new HashMap <> (); für (Mitarbeiter e: data) {String key = separat (e.Salary); Liste <Wepodee> l = result.get (Schlüssel); if (l == null) {l = new ArrayList <> (); result.put (key, l); } l.add (e); } return Ergebnis; <br>} private statische Zeichenfolge separat (int -Gehalt) {if (Gehalt <= 5000) {return "weniger als 5000"; } if (Gehalt <= 10000) {return "5000 ~ 10000"; } if (Gehalt <= 20000) {return "10000 ~ 20000"; } zurück "über 20000"}}Dann sagte der Chef erneut: Teilen wir die Mitarbeiter nach ihrem Beschäftigungsjahr in Gruppen ein. . .
Ich werde den Code hier nicht schreiben. Wenn Sie es vergleichen, werden Sie feststellen, dass die einzige Änderung die Möglichkeit ist, den Schlüsselwert auszuwählen, egal wie Sie es gruppieren.
Der erste Brief des Namens des Mitarbeiters wird zum ersten Mal als Schlüssel verwendet:
Mitarbeiter e -> e.name.charat (0)
Beim zweiten Mal konvertiere ich das Gehalt des Mitarbeiters in die Zeichenfolge als Schlüssel gemäß der Methode Separat:
Mitarbeiter E -> getrennt (e.salary): Zeichenfolge
Und so weiter
Mitarbeiter E -> Getyear (E.Time): String
Tatsächlich können Sie beim ersten Mal auch den ersten Buchstaben in eine einzelne Methode schreiben.
Mitarbeiter E -> getFirstchar (e.Name): Zeichen
Um schöner auszusehen, können wir sagen, dass die Parameter der drei Methoden an die Mitarbeiter eingestellt sind. Die Methodekörper ist nicht geschrieben. Hier sind nur die Parameter und Rückgabewerte aufgeführt.
Mitarbeiter e -> getFirstchar (e): charakterometer e -> separat (e): StringAmnee e -> Getyear (e): String
Die linke Seite von -> ist der Parameter, die rechte Seite von: ist der Rückgabewert und die rechte Seite von -> ist die Signatur der Methode
Dann werden wir natürlich daran denken, den geänderten Teil als Parameter und andere unveränderte Teile als Methodenkörper zu extrahieren, damit wir den doppelten Code weglassen können. Offensichtlich ist der geänderte Teil die oben aufgeführte Methode, die die Mitarbeiter E in Schlüssel umwandelt, aber wir wissen, dass Java keine Methoden als Parameter übergeben kann. Dies ist jedoch kein Problem für Programmierer mit ein wenig Erfahrung. Wir können Schnittstellen verwenden, um unsere Ziele zu erreichen, und gleichzeitig werden wir auf ein anderes Problem stoßen. Die Rückgabewerte der oben genannten drei Methoden sind unterschiedlich, daher müssen wir Generika verwenden:
public static <k> map <k, list <Mitarbeiter >> GroupByKey (Liste <Personal> Daten, getKey <K> getKey) {map <k, Liste <Mitarbeiter >> result = new Hashmap <> (); für (Mitarbeiter e: data) {k key = getKey.getKey (e); Liste <Wepodee> l = result.get (Schlüssel); if (l == null) {l = new ArrayList <> (); result.put (key, l); } l.add (e); } Rückgabeergebnis;} Schnittstelle getKey <k> {k getKey (Mitarbeiter e);}Dann kann die erste Anforderung oben auf diese Weise realisiert werden
Karte <Charakter, Liste <Mitarbeiter >> result = GroupByKey (Daten, neu GetKey <Scharakter> () {@Override public Charakter getKey (Mitarbeiter e) {e.Name.charat (0);}});Die zweite Anforderung
Karte <String, Liste <Mitarbeiter >> result = GroupByKey (Liste, New getKey <string> () {@Override public String getKey (Mitarbeiter e) {separat (e.salary);}});Es ist festzustellen, dass wir nur die generischen Parameter und die Implementierung anonymer interner Klassen ändern müssen. Das einzige Problem ist, dass es nicht sehr realistisch ist und viele Routinecodes besonders in anonymen internen Klassen widerspiegeln.
Tatsächlich kümmern wir uns nur um die Parameter und Rückgabewerte dieser anonymen inneren Klasse, und der Rest sind nur Syntaxanforderungen.
Java8 bietet uns einfach eine gute Möglichkeit, komplizierte Routinen zu vermeiden: Lambda -Ausdrücke, die obige Implementierung kann geschrieben werden
Karte <Zeichen, Liste <Mitarbeiter >> resultByFirstchar = GroupByKey (Liste, E -> e.Name.Charat (0)); Karte <String, Liste <Mitarbeiter >> resultbySalary = GroupByKey (Liste, E -> separat (e.salary));
Lambda -Ausdrücke zeigen nur, worum es uns wichtig ist, Parameter und Rückgabewerte. Gleichzeitig können Parametertypen aufgrund von Typinferenz weggelassen werden. Die spezifische Syntax wird hier nicht eingeführt. Im Internet finden Sie viele Informationen
Extra:
Wenn Sie ein gutes Verständnis für Generika haben, kann der Method GroupByKey weiter abstrahiert werden:
public static <k, e> map <k, list <e >> GroupBy (Liste <? Erweitert E> Daten, Funktion <? Super e,? Erweitert K> Fun) {map <k, list <e >> result = new Hashmap <> (); für (e e: data) {k k = fun.apply (e); <br> list <e> l = result.get (k); if (l == null) {l = new ArrayList <> (); result.put (k, l); } l.add (e); } Rückgabeergebnis; <br>}Wir haben auch die Mitarbeiterklasse extrahiert, und die Vorteile sind offensichtlich
Die Funktionsinterface ist eine neu hinzugefügte Schnittstelle zu Java8:
@FunctionalInterfacepublic -Schnittstellenfunktion <t, r> {r anwenden (t t);}Geben Sie einen t -Typ ein, um zum R -Typ zurückzukehren. Die Kombination von Generika und funktionaler Programmierung ist sehr gut. Obwohl die neuen Merkmale von Java8 durch verschiedene Arten von Beschwerden kritisiert wurden, ist es immer gut, Vorteile zu bringen, was uns mehr Möglichkeiten gibt.
Wenn Sie Zeit haben, werde ich Stream vorstellen, ein weiteres großartiges Werkzeug für Java8
Die oben genannte Anwendung von Lambda -Ausdrücken in Java 8 und einigen generischen Kenntnissen, die Ihnen vom Herausgeber vorgestellt wurden. Ich hoffe, es wird Ihnen hilfreich sein. Wenn Sie Fragen haben, hinterlassen Sie mir bitte eine Nachricht und der Editor wird Ihnen rechtzeitig antworten. Vielen Dank für Ihre Unterstützung auf der Wulin.com -Website!