Las expresiones lambda en Java
Lo que es expresiones lambda
Las expresiones lambda se se añade una función anónima en jdk1.8
antes jdk1.8, sólo podemos utilizar métodos anónimos y las interfaces de herencia para poner en práctica el método definido en la interfaz
usando expresiones lambda también son limitadas, la expresión Lambda tipo sólo puede tener uno y único método que no está implementado en la interfaz utilizada
tanto, en jdk1.8 también agregó una palabra clave por defecto, el método por defecto está marcada por la necesidad de escribir una implementación por defecto
simple uso de expresiones lambda
En primer lugar, vamos a definir unos interfaces, éstas se definen únicamente por conveniencia expresiones lambda muestran
/**
* 无返回值的接口
* @author Administrator
*
*/
interface SingleParameter
{
void printin(Object msg);
}
/**
* 有返回值的接口
* @author Administrator
*
*/
interface SingleParameterReturn
{
Integer triploid(Integer num);
}
/**
* 多参数有返回值的接口
* @author Administrator
*
*/
interface MultiParameterReturn
{
Integer triploid(Integer num,Integer num2);
}
/**
* 无参有返回值的接口
* @author Administrator
*
*/
interface PersonCreater {
Person getPerson();
}
/**
* 返回值对象
* @author Administrator
*
*/
class Person{
private LambdaDemo demo;
public Person()
{
demo=LambdaDemo.getLambdaDemo();
}
public LambdaDemo getDemo() {
return demo;
}
}
Después definido las interfaces que utilizamos para operar el Lambda Expresiones
SingleParameter singleParameter=s->{System.err.println(s);}; // 这是无返回值的lambda表达式
singleParameter.printin("这是无返回值的lambda表达式");
Debido a que
la interfaz SingleParameter sólo
printin vacío (msg Objeto); método no se implementa
de manera
s -> {System.err.println (s) ;}; esto puede ser visto como el código que implementa el método
s de métodos msg
-> representa el punto del cuerpo del método
{System.err.println (s);} implementar el método representativo
无返回值的方法实现了我们再来看有返回值的SingleParameterReturn是怎么实现的
SingleParameterReturn singleParameterReturn=s->s*3; // 这是无返回值的lambda表达式
System.err.println(singleParameterReturn.triploid(12));
SingleParameterReturn en el método no realizada es
Entero triploide (entero num);
sin embargo, en el código anterior se escribe sólo una pequeña pieza de código para que pueda reemplazar este método
S> S 3
S sigue siendo la misma en nombre de los métodos num
-> método de punto cuerpo
S . 3 es en realidad igual retorno s * 3; sólo el taquigrafía anteriormente
Dado que se conocen los parámetros individuales, entonces las expresiones lambda que miran multiparamétrico
MultiParameterReturn multiParameterReturn=(s,m)->s*m; // 这是有返回值的多参数的lambda表达式 多参数时必须加上小括号
System.err.println(multiParameterReturn.triploid(12,30));
MultiParameterReturn en el método no realizada es
Entero triploide (NUM entero, entero num2);
las expresiones lambda son
(s, m) -> s m
gente muy inteligente ya han visto que esto es lo que significa
s representantes NUM
m Código num2
-> dirigida a un cuerpo de método
S m es realmente devuelto multiplicar dos números
A continuación, llamar a los métodos de otras clases desde múltiples parámetros parámetro único que tenemos que entender la dificultad de mejoramiento Las expresiones lambda
SingleParameter singleParameter2=System.err::println; // 这是调用其他类的方法的lambda表达式
singleParameter2.printin("这是调用其他类的方法的lambda表达式");
System.err :: PRINTLN;
esto es en realidad muy simple significado del código
antes :: se llama objeto
se invoca el método después ::
Esto es equivalente a usar System.err.println (); en cambio nuestro enfoque
Aparentemente difíciles de actualizar, de hecho, es tan fácil de entender
que venimos pasado para crear objetos usando métodos de implementación objeto expresiones lambda
PersonCreater p1=()->new Person(); //这是创建对象的lambda表达式
PersonCreater p2=Person::new; //这是创建对象的lambda表达式 这种写法等价于上面那种写法
System.err.println(p1.getPerson().getDemo()==p2.getPerson().getDemo());
La primera no es más que un ladrón
() método en nombre vaciar
-> cuerpo método de ejecución
objetos Nuevo método devuelve Persona () los implementan para crear un
segundo un poco posible poco difícil
, pero los dos son para ver a crear los objetos de la interfaz, muestra
( ;> new Persona () -) ; y la persona :: nueva
aplicación interna es la misma
persona se para representar el objeto operación
se crea nuevo objeto en nombre de
toda la vuelta final es el objeto creado
un uso simple de lo anterior es Lambda
Lambda expresiones escenarios de uso
El ejemplo más simple
Lista de forEach
que es mostrar la mayor parte Lambda utilizar
su velocidad no sólo reduce la cantidad de código que también mejora el código
de la vista de lista usando
expresiones lambda No es de extrañar, entonces será el desarrollo futuro de tendencia
