lambda es una función anónima, que puede ser entendido como un código para lambda puede ser pasado (código de acceso es el mismo que el de datos), puede escribir código más conciso y más flexible.
Primer vistazo a las implementaciones de clase internas anónimas originales (por ejemplo, en un comparador)
// anónima clases internas implementación original
pública test1 void () {
// definir una clases internas anónimas Comparador
Comparador <entero> = new nueva Comparador Comparador <Integer> () {
@ Override
public int Comparar (O1 entero, entero O2) { retorno Integer.compare (O1, O2);
}
};
// clases internas anónimas como un objeto pasado TreeSet <Integer> = new nuevo TreeSet TreeSet <> (Comparador);
}
El código anterior es en realidad código útil en realidad sólo dos líneas (línea 7), pero tiene que escribir tanto código, muy doloroso, lambda buena solución al problema.
aplicación lambda
// expresión lambda para implementar
test2 public void () {
// expresión lambda
Comparador <Integer> = Comparador (X, Y) -> Integer.compare (X, Y);
// clases internas anónimas como un objeto pasa
TreeSet <Integer> = new nuevo TreeSet TreeSet <> (Comparador);
}
A través de lo anterior se puede observar, las líneas originales de código, la línea se dieron cuenta, en gran medida reducidos gran cantidad de código, pero sólo si tal conclusión, obviamente, no puede convencer a la gente (clases internas anónimas que pueden generar directamente una clave, que se desarrollará dijo que el impacto no es grande, pero para aprender una nueva sintaxis, la relación de entrada-salida no es demasiado grande)
por lo que dar otro ejemplo para ilustrar las ventajas de lambda:
Requisito 1: Get empleados en más de 35 años de edad de la compañía
En primer lugar crear clases de entidad
com.example.jdk8demo.lambda empaquetar; lombok.AllArgsConstructor importación; lombok.Data importación; lombok.RequiredArgsConstructor importación; lombok.ToString importación; @Data @RequiredArgsConstructor @AllArgsConstructor @ToString pública clase empleador { privado String nombre; privada edad Integer; privada doble sueldo; }
Para facilitar la presentación, las operaciones de bases de datos ya no son directamente simular un conjunto de empleados
/ * * * Empleados Conjunto analógicas * / Privado Lista <Patrón> Lista = Arrays.asList ( nuevo nuevo empleador ( " Joe Smith " , 18 es , 2.222,22 ), nueva nuevo empleador ( " John Doe " , 32 , 3333.33 ), nueva nuevo empleador ( " Wu Wang " 52 , 4444.44 ), nueva nuevo empleador ( " Zhao seis " , 44 , 5555.55 ), nuevo nuevo empleador ( " Tianqi " , 8 , 4235.32 ), nueva nuevo empleador ( " ganado ocho " , 28 , 3256,52 ) );
se implementa entonces código de la lógica, vamos a definir directamente un método general para lograr, el siguiente código mostrado en la figura.
/ * * *查询年龄大于35岁的员工 * @return * / pública Lista <Patrón> getEmpolyerByAge () { Lista <Patrón> employerList = nuevo ArrayList <> (); para (PATRÓN: lista) { si (employer.getAge ()> 35 ) { employerList.add (empleador); } } Volver employerList; }
Así que si esta vez, de nuevo una demanda
Requisito 2: Consulta mayor salario de 4000 empleados
También tenemos que escribir un método de implementación
/ * * *查询工资大于4000的员工 * @return * / pública Lista <Patrón> getEmpolyerBySalary () { Lista <Patrón> employerList = nuevo ArrayList <> (); para (PATRÓN: lista) { si (employer.getSalary ()> 4000 ) { employerList.add (empleador); } } Volver employerList; }
Se puede encontrar ambos métodos, sólo se employer.getAge ()> 35 y employer.getSalary ()> 4000 es diferente del resto del código es el mismo, si hay un aumento posterior de nuevas necesidades similares, entonces sería código redundante cada vez más, por lo que necesitamos para optimizar el código.
Una opción de optimización: Utilice el patrón de Estrategia
En general, para este código redundante, vamos a utilizar la estrategia de optimización de modo a optimizar el
En primer lugar, crear una interfaz
com.example.jdk8demo.lambda empaquetar; público interfaz EmpolyerService <T> { filtro booleano (T t); }
A continuación, para diferentes necesidades, hacer diferente clase de implementación
La primera clase de implementación es mayor que la edad de 35 empleados para la investigación
com.example.jdk8demo.lambda empaquetar; público de clase implementos EmpolyerImplByage EmpolyerService <Patrón> { @ Override pública filtro booleano (PATRÓN) { retorno employer.getAge ()> 35 ; } }
La segunda es la clase de implementación para las empresas a más de 4000 empleados
com.example.jdk8demo.lambda empaquetar; público de clase implementos EmpolyerImplBySalary EmpolyerService <Patrón> { @ Override pública booleano filtro (PATRÓN) { volver employer.getSalary ()> 4000 ; } }
A continuación, la política es utilizar el modo de consulta, la referencia es lograr un método de la interfaz de la clase y luego procesa de manera diferente según las diferentes implementaciones de los métodos de interfaz clase de implementación.
/ * * *使用策略模式查询员工信息 * @param empolyerService * @return * / pública Lista <Patrón> getEmpolyerList (EmpolyerService <Patrón> empolyerService) { Lista <Patrón> employerList = nuevo ArrayList <> (); para (PATRÓN: lista) { si (empolyerService.filter (empleador)) { employerList.add (empleador); } } Volver employerList; }
Modo método Estrategia demanda final son todas las llamadas unificada nuevo, la referencia específica es la interfaz en una categoría específica
/ * * *优化一:采用策略模式 * / público vacío test5 () { Lista <Patrón> employerList = getEmpolyerList ( nueva EmpolyerImplByage ()); para (PATRÓN: employerList) { log.info (employer.toString ()); } Log.info ( " ============================================ = " ); employerList = getEmpolyerList ( nuevo EmpolyerImplBySalary ()); para (PATRÓN: employerList) { log.info (employer.toString ()); } }
Esta optimización hay lugares malos, es un requisito crearía una clase de implementación, junto con el aumento de la demanda, la clase de implementación será más y más, es el momento para refinar
Opción optimización Dos: Utilice una clases internas anónimas
Como resultado del patrón de estrategia, es necesario crear una demanda de una clase de implementación, lo que lleva a un aumento de archivos, por lo que puede cambiar el modo de la política de utilizar la clase interna anónima, usando clases internas anónimas, aún es necesario filtrar la interfaz anterior, pero ya no hay necesidad de utilizar la clase de implementación de la interfaz
/ * * *优化方式二:匿名内部类 * / público vacío test6 () { Lista <Patrón> employerList = getEmpolyerList ( nueva EmpolyerService <Patrón> () { @ Override pública filtro booleano (PATRÓN) { retorno employer.getAge ( )> 20 ; } }); para (PATRÓN: employerList) { log.info (employer.toString ()); } Log.info ( " ============================================ = " ); employerList= GetEmpolyerList ( nueva EmpolyerService <Patrón> () { @ Override pública booleano filtro (PATRÓN) { volver employer.getSalary ()> 3000 ; } }); para (PATRÓN: employerList) { log.info (employer.toString ()); } }
Teniendo así se corresponde con el momento del comienzo de este artículo, un código de clase interna anónima es realmente útil en una línea, pero la falta de necesidad de escribir una serie de otros códigos sin usar, por lo que puede utilizar la optimización lambda.
Opción optimización Tres: El uso de lambda
/ * * *优化方式七: lambda表达式 * / público vacío test7 () { LambdaTest lambdaTest = nueva LambdaTest (); Lista <Patrón> employerList = lambdaTest.getEmpolyerList ((E) -> e.getAge ()> 30 ); employerList.forEach (Sistema. cabo :: println); log.info ( " ============================================= " ); employerList = lambdaTest.getEmpolyerList ((E) -> e.getSalary ()> 3000 ); employerList.forEach (Sistema. cabo :: println); }
Se puede encontrar, el uso de las expresiones lambda, el código es simple y concisa. Hasta aquí, por qué el uso de lambda ha sido descrita se ha completado, pero para java8, todavía hay forma más concisa de la optimización es el flujo de corriente.
Optimización de cuatro maneras: el flujo de corriente
Para esta implementación, no tenemos los mismos que los primeros tres nuevas formas de optimizar la interfaz, donde la filtración de flujo puede ser utilizado directamente.
/ * * * Consulta StreamAPI usando la información del empleado * / público vacío test8 () { list.stream () // streaming de .Filter ((E) -> e.getSalary ()> 2000 ) // filtrada mayor salario de 2000 el personal .Filter ((E) -> e.getAge ()> 30 ) // filtrada a los empleados mayores de 30 años .Limite ( 2 ) // sólo las dos primeras consultas .forEach (Sistema. oUT :: el println); // impresión bucle }