Je n'écrirai pas la partie syntaxe, soulevons simplement une question pratique pour voir quelles commodités ces nouvelles fonctionnalités de Java8 peuvent nous apporter.
Soit dit en passant, une programmation générique est utilisée, tout est pour simplifier le code
Scène:
Une classe de données qui enregistre les informations des employés
Employé de classe publique {nom de chaîne publique; L'âge public; Sexe de charbon public; Temps de chaîne publique; public int salaire;}Nous avons une colonne de ce type de données
Liste <employee> data = arrays.aslist (e1, e2, e3 ......)
Il y a un besoin maintenant: les employés du groupe par la lettre initiale de leurs noms (en supposant qu'ils sont tous des noms d'anglais):
Ensuite, le résultat que nous voulons obtenir devrait être une relation de cartographie comme Map：char -> List<Employee>
MAP STATIQUE PUBLIQUE <Caractère, List <Lesyee >> GroupByFirstChar (List <Employee> Data) {Map <Caracter, List <Employee> Result = new Hashmap <> (); pour (employé e: data) {caractère c = e.name.charat (0); List <employee> l = result.get (c); if (l == null) {l = new ArrayList <> (); result.put (c, l); } l.add (e); } Retour Résultat;}Le code n'est pas compliqué et peut être achevé bientôt. Le patron voit que vous êtes si efficace, alors il a dit que vous le divisez en groupes en fonction de votre salaire, pour ceux qui sont inférieurs à 5 000, 5 000 ~ 10 000 ... etc.
Ce ne sera pas trop difficile, il suffit de changer la clé et de le traiter un peu logiquement
MAP STATIQUE publique <String, List <Lesyee >> GroupBysalary (list <employee> data) {map <string, list <employee >> result = new Hashmap <> (); pour (employé e: data) {String key = séparé (e.salary); List <employee> l = result.get (key); if (l == null) {l = new ArrayList <> (); result.put (key, l); } l.add (e); } Retour Résultat; <br>} chaîne statique privée séparée (int salaire) {if (salaire <= 5000) {return "moins de 5000"; } if (salaire <= 10000) {return "5000 ~ 10000"; } if (salaire <= 20000) {return "10000 ~ 20000"; } Retour "Au-dessus de 20000"}Ensuite, le patron a dit à nouveau, divisons les employés en groupes en fonction de leur année d'emploi. . .
Je n'écrirai pas le code ici. Si vous le comparez, vous constaterez que peu importe la façon dont vous le regroupez, le seul changement est le moyen de sélectionner la valeur clé.
La première lettre du nom de l'employé est utilisée comme clé pour la première fois:
Employé E -> E.Name.Charat (0)
La deuxième fois, je convertit le salaire de l'employé en chaîne comme clé selon la méthode séparat:
Employé E -> séparé (e.salary): chaîne
Et ainsi de suite
Employé E -> Getyear (E.Time): String
En fait, la première fois, vous pouvez également écrire la première lettre en une seule méthode.
Employé E -> getFirstChar (e.name): caractère
Afin de paraître plus beau, nous pouvons dire que les paramètres des trois méthodes sont définis à l'employé. Le corps de la méthode n'est pas écrit. Seuls les paramètres et les valeurs de retour sont répertoriés ici.
Employee E -> GetFirstChar (E): CaractEmployee E -> séparé (E): StringEmployee E -> Getyear (E): String
Le côté gauche de -> est le paramètre, le côté droit de: est la valeur de retour, et le côté droit de -> est la signature de la méthode
Ensuite, nous penserons naturellement à extraire la partie modifiée comme des paramètres et d'autres parties inchangées comme des corps de méthode, afin que nous puissions omettre le code en double. De toute évidence, la partie modifiée est la méthode énumérée ci-dessus, qui convertit l'employé en clé, mais nous savons que Java ne peut pas passer les méthodes comme paramètres. Cependant, ce n'est pas un problème pour les programmeurs avec un peu d'expérience. Nous pouvons utiliser des interfaces pour atteindre nos objectifs, et en même temps, nous rencontrerons un autre problème. Les valeurs de retour des trois méthodes ci-dessus sont différentes, nous devons donc utiliser des génériques:
public static <k> map <k, list <lyeyee> groupbykey (list <lyeyee> data, getkey <k> getkey) {map <k, list <employee >> result = new hashmap <> (); pour (employé e: data) {k key = getKey.getKey (e); List <employee> l = result.get (key); if (l == null) {l = new ArrayList <> (); result.put (key, l); } l.add (e); } Retour Résultat;} Interface Getkey <K> {K Getkey (Employé E);}Ensuite, la première exigence ci-dessus peut être réalisée de cette manière
Map <caractère, list <employee>> result = groupBykey (data, new GetKey <acactring> () {@Override public Character getKey (employee e) {e.name.charat (0);}});La deuxième exigence
Map <string, list <employee >> result = groupBykey (list, new GetKey <string> () {@Override public String getKey (employee e) {séparé (e.salary);}});On peut constater que nous devons seulement modifier les paramètres génériques et l'implémentation de classes internes anonymes. Le seul problème est qu'il n'est pas très réaliste et que de nombreux codes de routine se reflètent particulièrement dans les classes internes anonymes.
En fait, nous ne nous soucions que des paramètres et des valeurs de retour de cette classe intérieure anonyme, et les autres ne sont que des exigences de syntaxe.
Java8 se trouve simplement nous fournir un bon moyen d'éviter les routines compliquées: les expressions de lambda, l'implémentation ci-dessus peut être écrite comme
Map <caractère, list <employee >> resultByFirstChar = groupBykey (list, e -> e.name.charat (0)); map <string, list <employee >> resultAcyalary = groupByKey (list, e -> séparé (e.salary));
Les expressions Lambda ne montrent que ce que nous nous soucions, les paramètres et les valeurs de retour. Dans le même temps, en raison de l'inférence de type, les types de paramètres peuvent être omis. La syntaxe spécifique ne sera pas introduite ici. Beaucoup d'informations peuvent être trouvées sur Internet
supplémentaire:
Si vous avez une bonne compréhension des génériques, la méthode GroupBykey peut être encore abstraite:
public static <k, e> map <k, list <e>> groupby (list <? étend e> data, function <? super e ,? étend k> fun) {map <k, list <e>> result = new hashmap <> (); pour (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); } Retour Résultat; <br>}Nous avons également extrait la classe des employés, et les avantages sont évidents
L'interface de fonction est une interface nouvellement ajoutée à Java8:
@FunctionalInterFacePublic Interface Fonction <T, R> {r Appliquer (t T);}Entrez un type t pour revenir à Rype R. La combinaison des génériques et de la programmation fonctionnelle est très bonne. Bien que les nouvelles fonctionnalités de Java8 aient été critiquées par divers types de plaintes, il est toujours bon d'apporter des avantages, ce qui nous donne plus de choix.
Si vous avez le temps, je présenterai Stream, un autre excellent outil pour Java8
Ce qui précède est l'application des expressions de lambda dans Java 8 et certaines connaissances génériques liées à vous être présentées par l'éditeur. J'espère que cela vous sera utile. Si vous avez des questions, veuillez me laisser un message et l'éditeur vous répondra à temps. Merci beaucoup pour votre soutien au site Web Wulin.com!