No escribiré la parte de sintaxis, planteemos una pregunta práctica para ver qué comodidades pueden traernos estas nuevas características de Java8.
Por cierto, se usa alguna programación genérica, todo es para simplificar el código
Escena:
Una clase de datos que registra la información de los empleados
Empleado de clase pública {nombre de cadena pública; Public int Age; Sexo de carbón público; tiempo de cadena pública; salario público int;}Tenemos una columna de este tipo de datos
Lista <Eloza> data = arrays.aslist (E1, E2, E3 ......)
Ahora hay una necesidad: empleados grupales de empleados por la carta inicial de sus nombres (suponiendo que todos son nombres de inglés):
Entonces, el resultado que queremos obtener debe ser una relación de mapeo como Map：char -> List<Employee>
Mapa estático público <caracteres, Lista <Elegial>> GroupByFirstChar (List <Elpagee> Data) {Map <caracteres, List <Elseage> Result = new HashMap <> (); para (Empleado E: Data) {carácter c = e.name.charat (0); Lista <Eloza> L = resultado.get (c); if (l == null) {l = new ArrayList <> (); resultado.put (C, L); } l.add (e); } resultado de retorno;}El código no es complicado y se puede completar pronto. El jefe ve que eres tan eficiente, por lo que dijo que lo dividirás en grupos de acuerdo con tu salario, para aquellos inferiores a 5,000, 5,000 ~ 10,000 ... etc.
No será demasiado difícil, solo cambia la clave y procesa un poco lógicamente.
Public Static Map <String, List <Elseage>> GroupBySalary (List <Elpagee> Data) {MAP <String, List <Elsagee> Result = new HashMap <> (); para (empleado e: data) {string key = separado (e.salary); Lista <Eloza> l = resultado.get (clave); if (l == null) {l = new ArrayList <> (); resultado.put (clave, l); } l.add (e); } resultado de retorno; <br>} cadena estática privada separada (int salario) {if (salario <= 5000) {return "menos de 5000"; } if (salario <= 10000) {return "5000 ~ 10000"; } if (salario <= 20000) {return "10000 ~ 20000"; } retorno "por encima de 20000"}Luego, el jefe dijo nuevamente, dividamos a los empleados en grupos de acuerdo con su año de empleo. . .
No escribiré el código aquí. Si lo compara, encontrará que no importa cómo lo agrupe, el único cambio es la forma de seleccionar el valor clave.
La primera letra del nombre del empleado se usa como clave por primera vez:
Empleado E -> E.Name.Charat (0)
La segunda vez que convierto el salario del empleado en cadena como clave de acuerdo con el método separat:
Empleado E -> separado (E.SALARY): cadena
Etcétera
Empleado E -> Getyear (E.Time): cadena
De hecho, la primera vez que también puede escribir la primera letra en un solo método.
Empleado E -> GetFirstchar (E.Name): Carácter
Para lucir más bello, podemos decir que los parámetros de los tres métodos están establecidos para los empleados. El cuerpo del método no está escrito. Solo los parámetros y los valores de retorno se enumeran aquí.
Empleado E -> getFirstchar (e): caracteressemleSployee e -> separado (e): stringeMployee e -> getyear (e): cadena
El lado izquierdo de -> es el parámetro, el lado derecho de: es el valor de retorno y el lado derecho de -> es la firma del método
Luego, naturalmente, pensaremos en extraer la parte cambiada como parámetros y otras partes sin cambios como cuerpos de método, por lo que podemos omitir el código duplicado. Obviamente, la parte cambiada es el método enumerado anteriormente, que convierte a los empleados E en clave, pero sabemos que Java no puede pasar los métodos como parámetros. Sin embargo, esto no es un problema para los programadores con un poco de experiencia. Podemos usar interfaces para lograr nuestros objetivos, y al mismo tiempo encontraremos otro problema. Los valores de retorno de los tres métodos anteriores son diferentes, por lo que necesitamos usar genéricos:
public static <k> map <k, list <aza empleado>> groupbykey (list <alegeS> data, getKey <K> getKey) {map <k, list <empleado>> resultado = new HashMap <> (); para (Empleado E: Data) {k key = getKey.getKey (e); Lista <Eloza> l = resultado.get (clave); if (l == null) {l = new ArrayList <> (); resultado.put (clave, l); } l.add (e); } resultado de retorno;} interfaz GetKey <K> {K getKey (Empleado E);}Luego, el primer requisito anterior se puede realizar de esta manera
MAP <CARACTER, LIST <Employee>> result = GroupByKey (Data, New GetKey <caracteres> () {@Override Public Caracter getKey (Empleado E) {e.name.charat (0);}});El segundo requisito
MAP <String, List <Employee>> result = GroupByKey (List, New GetKey <String> () {@Override public String getKey (Empleado E) {separado (E.Salary);}});Se puede encontrar que solo necesitamos cambiar los parámetros genéricos y la implementación de clases internas anónimas. El único problema es que no es muy realista, y muchos códigos de rutina se reflejan especialmente en clases internas anónimas.
De hecho, solo nos importa los parámetros y los valores de devolución de esta clase interna anónima, y el resto son solo requisitos de sintaxis.
Java8 simplemente nos proporciona una buena manera de evitar rutinas complicadas: expresiones lambda, la implementación anterior se puede escribir como
MAP <CARACTER, LIST <Empleado >> ResultByFirstChar = GroupByKey (List, E -> E.Name.Charat (0)); Map <String, List <Elseage>> resultBySalary = GroupByKey (List, E -> separado (E.Salary));
Las expresiones de Lambda solo muestran lo que nos importa, parámetros y valores de retorno. Al mismo tiempo, debido a la inferencia de tipo, se pueden omitir los tipos de parámetros. La sintaxis específica no se introducirá aquí. Se puede encontrar mucha información en Internet
extra:
Si tiene una buena comprensión de los genéricos, el método GroupByKey puede abstraerse aún más:
public static <k, e> map <k, list <E>> groupby (list <? extiende e> datos, función <? Super e, "extiende k> diversión) {map <k, list <E>> result = new HashMap <> (); para (e e: data) {k k = divers.apply (e); <br> list <E> l = result.get (k); if (l == null) {l = new ArrayList <> (); resultado.put (k, l); } l.add (e); } resultado de retorno; <br>}También hemos extraído la clase de empleados, y los beneficios son obvios
La interfaz de función es una interfaz recientemente agregada a Java8:
@FunctionalInterfacePublic Interface Función <t, r> {r Apply (t t);}Ingrese un tipo T para volver al tipo R. La combinación de genéricos y programación funcional es muy buena. Aunque las nuevas características de Java8 han sido criticadas por varios tipos de quejas, siempre es bueno traer beneficios, lo que nos da más opciones.
Si tienes tiempo, presentaré Stream, otra gran herramienta para Java8
Lo anterior es la aplicación de expresiones lambda en Java 8 y algún conocimiento genérico relacionado con el editor que le presenta el editor. Espero que te sea útil. Si tiene alguna pregunta, déjame un mensaje y el editor le responderá a tiempo. ¡Muchas gracias por su apoyo al sitio web de Wulin.com!