Las expresiones lambda han sido sentimiento es una técnica muy "big up", si se dirige a sí mismo puede reducir la cantidad de código a la metamorfosis de la razón, o desea que la herramienta de carga a la fuerza artefacto (es broma!) Gracias a medida que bien valen la pena aprender de onda.
Así, seguir adelante! Las expresiones lambda son nada más que el siguiente formato:
(parámetros) -> expresión 或 (parámetros) -> {sentencias; }
Sintaxis y de hecho el mismo que el método tradicional, la flecha de la izquierda es una lista de parámetros, por supuesto, pueden ser vacío; la flecha derecha es una expresión o un segmento de código. Ha puesto en marcha una expresión lambda, es para que pueda reemplazar la función de la interfaz por la expresión.
Se requiere una atención especial, el uso de las expresiones lambda es un requisito previo, y que sólo es una función de la interfaz de métodos para utilizar lambda como método cuando se le llama. ¿Qué significa eso concretamente? En primer lugar, mirar lo que es la interfaz de la función?
De hecho, la interfaz de la función es esencialmente una interfaz, pero es una interfaz especial: tipo SAM de interfaz (método único, el resumen) . En otras palabras, la interfaz es solamente un método abstracto, y no más, ni menos. Usted puede tener métodos estáticos y el método por defecto, debido a que ambos métodos ya están implementadas a. Al mismo tiempo, esto no debe ser un método abstracto con el mismo nombre en el método de la clase Object. Java8 nueva característica proporciona una interfaz de función, un mejor soporte para la programación funcional. (El conocimiento específico de la interfaz de la función puede hacer referencia a otro blog Java 8 funciones e interfaces Lambda notas de estudio (b) )
Lo siguiente de lo simple a lo complejo proceso de aprender sistemáticamente acerca de las expresiones lambda, con la esperanza de descubrir anormal para mí que el velo del misterio!
En primer lugar, un ejemplo simple es la expresión lambda, se puede profundizar en la comprensión de sus conceptos a través de estas pequeñas castañas.
// 1. 不需要参数,返回值为 5
() -> 5
// 2. 接收一个参数(数字类型),返回其2倍的值
x -> 2 * x
// 3. 接受2个参数(数字),并返回他们的差值
(x, y) -> x – y
// 4. 接收2个int型整数,返回他们的和
(int x, int y) -> x + y
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) -> System.out.print(s)Para el tercer ejemplo, tratamos de lograrlo, el código es el siguiente:
package com.wjb.lambda;
/**
* 函数式接口：
* 1.只能有一个抽象方法
2.可以有静态方法和默认方法，因为这两种方法都是已经实现的了
3.这个抽象方法一定不能跟Object类中的方法同名。
* @author Administrator
*
*/
@FunctionalInterface
interface Fun{
//只设置一个抽象方法 ------可以正常运行
abstract int spend(int remaining,int money);
//加入静态方法和默认方法 ----可以正常运行
static void staticMethod() {
System.out.println("There is a static method!");
}
default void defaultMethod() {
System.out.println("There is a default method!");
}
//设置Object中可以重写的抽象方法 ----编译报错
// abstract boolean equals(Object obj);
}
public class FunInterface{
public static void main(String[] args) {
Fun fun = (a,b) -> a-b;
System.out.println(fun.spend(100, 5));
}
}
Al parecer, la expresión lambda es realmente muy simple.
A continuación, echamos un vistazo a la escena utilizado expresiones lambda:
1. iterador de la lista
Para cada elemento de la lista de una operación, como cuando no se utiliza una expresión Lambda:
List<Integer> list = Arrays.asList(1,2,3,4,5);
for (Integer integer : list) {
System.out.println(list);
}Las expresiones lambda utilizando las palabras es la forma en que?
List<Integer> list = Arrays.asList(1,2,3,4,5);
list.forEach((integer2) -> System.out.println(integer2));
Cola para entrar! Sin embargo, cabe destacar que, foreach java 8 método propuesto es darse cuenta de su subyacente aceptar interfaz Consumidor método, por lo que puede utilizar las expresiones lambda como parámetros.
Si sólo necesita una función única elementos de la lista de llamadas para el procesamiento, se puede utilizar un más compacto 方法引用 en lugar de expresiones lambda:
list.forEach(System.out::println);Aquí las referencias de métodos pertenecen a extenderse, mirada puede interesados en este blog de Java método de referencia 8
Éstos son algunos escenarios de desarrollo de bienes que pueden surgir, echar un vistazo a la expresión lambda es realmente sorprendente:
(1) Por ejemplo: objeto de lista para obtener un nuevo campos individuales de la lista <Objeto> lista de objetos,
Cuando lleguemos identificación de la lista de todos los usuarios de la lista <usuario> lista_usuarios y forman una nueva lista de cómo hacerlo, de manera inusual de lograr, pero demasiado complicado
List<Long> userIdList = userList.stream.map(User::getUserId).collect(Collectors.toList());Se propone una característica muy importante de Java 8 Stream, los detalles se pueden ver notas de estudio de Java 8 Stream
(2) Modificar de Lista <usuario> valor en un lista_usuarios objeto de campo
List<User> userList;//获取所有用户的Id列表
userList.foreach(User -> User.setUserId(User.getUserId+1));(3) modificar la pluralidad de valores de los parámetros List <usuario> lista_usuarios en
userList.foreach((x) -> {x.setUserId(0L); x.setUserName(""); x.setUserSex(0);})valor (4) lista filtrada
List<String> list
//过滤null值
list.stream.filter(x -> x != null).collect(Collectors.toList());
//过滤特定值(包括空字符串"")
list.stream.filter(x -> !"str".equals(x)).collect(Collectors.toList());(5) una lista de rotación cadena separada por comas <Larga>
List<Long> listIds = Arrays.asList(ids.split(",")).stream().map(s -> Long.parseLong(s.trim())).collect(Collectors.toList());función de código se transfiere después de la primera lista de cadenas es cortado en una matriz, a continuación, cuando se atraviesa el cuadro de lista se quita y se transfirió a un tipo de elementos largos, y finalmente transferido a la nueva lista.
(6) Lista transfectadas mapa (suponiendo una lista de la lista <FlowNodeTimeoutRuleUser> lista_usuarios)
//1.List对象中两个字段对应
Map<Long, String> userMap1 = userList.stream().collect(Collectors.toMap(FlowNodeTimeoutRuleUser::getUserId, FlowNodeTimeoutRuleUser::getUserName));
//2.List对象中字段和对象本体对应
Map<Long, String> userMap2 = userList.stream().collect(Collectors.toMap(FlowNodeTimeoutRuleUser::getUserId, x -> x));
//本体表达式可以用lambda表达式x->x 也可以使用接口Function.identity()
Map<Long, String> userMap3 = userList.stream().collect(Collectors.toMap(FlowNodeTimeoutRuleUser::getUserId, Function.identity()));
//3. List对象中key字段重复导致错误，增加一个lambda表达式(key1, key2) -> key2,后者覆盖前者解决key重复问题
Map<Long, String> userMap4 = userList.stream().collect(Collectors.toMap(FlowNodeTimeoutRuleUser::getUserId, Function.identity(), (key1, key2) -> key2));No entiendo un método particular puede ver el código fuente de saber.
(7) Liste el número de repeticiones estadísticas:
List<Integer> list = Arrays.asList(1,1,2,5,2,3,4,5);
//统计List中重复数量
Map<Integer,Long> map = list.stream().collect(Collectors.groupingBy(x -> x,Collectors.counting()));En el que la expresión lambda x> x es un elemento de lista en sí.
(8) Lista deduplicación Encontrado:
List.stream().distinct().collect(Collectors.toList());(9) El valor del objeto de lista Propiedad Valor deduplicación
List<Person> unique = persons.stream().collect(
Collectors.collectingAndThen(
Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(Person::getName))), ArrayList::new)
);(10) Lista ordenada de forma ascendente
List<User> userList;
userList.sort((User u1, User u2) -> u1.getAge().compareTo(u2.getAge()));2. Los detectores de eventos
No utilice expresiones lambda:
button.addActionListener(new ActionListener(){
@Override
public void actionPerformed(ActionEvent e) {
//handle the event
}
});Aquí está la realización de un métodos de la clase interna anónima utilizados.
Las expresiones lambda uso, cuando tiene que escribir varias instrucciones entre llaves:
button.addActionListener(e -> {
//handle the event
});3. Interfaz de predicados
paquete java.util.function de predicados para la interfaz se puede filtrar fácilmente. Si necesita filtrar la pluralidad de objetos y realiza la misma lógica de procesamiento, a continuación, estas mismas operaciones pueden ser empaquetados en método de filtro, criterios de filtrado proporcionados por la persona que llama, para su reutilización.
interfaces de predicado no se utiliza, para cada objeto, requiere la preparación de filtros y lógica de procesamiento:
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<String> words = Arrays.asList("a", "ab", "abc");
numbers.forEach(x -> {
if (x % 2 == 0) {
//process logic
}
})
words.forEach(x -> {
if (x.length() > 1) {
//process logic
}
})las interfaces de predicado utilizan la misma lógica de procesamiento de filtro para procesar el paquete, se llama repetidamente:
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<String> words = Arrays.asList("a", "ab", "abc");
filter(numbers, x -> (int)x % 2 == 0);
filter(words, x -> ((String)x).length() > 1);
}
public static void filter(List list, Predicate condition) {
list.forEach(x -> {
if (condition.test(x)) {
//process logic
}
})
}método de filtro también puede ser escrito como:
public static void filter(List list, Predicate condition) {
list.stream().filter(x -> condition.test(x)).forEach(x -> {
//process logic
})
}
mapa 4.Map
Mapa de flujo de objeto mediante el método de mapeo de la lista original a través de expresiones lambda es otra lista, y de vuelta convertidos a la lista cobrar por tipo de método:
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> mapped = numbers.stream().map(x -> x * 2).collect(Collectors.toList());
mapped.forEach(System.out::println);Después de la lista de elementos multiplicado por 2 para asignar una nueva lista, implementado formas Stream, mucho menos código.
5. Reducir la polimerización
reducir la operación, la polimerización se lleva a cabo por una operación binaria para todos los elementos, para obtener un resultado final. Por ejemplo, la adición polimerización de la lista, todos los elementos de la lista se acumula para obtener la suma.
Por lo tanto, podemos proporcionar un receptor de dos parámetros de una expresión Lambda reducen, esta expresión es equivalente a una operación binaria:
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream().reduce((x, y) -> x + y).get();
System.out.println(sum);Stream es una forma de lograr!
6. En lugar de Ejecutable
Esto es especialmente común escenarios siguientes para crear un hilo, por ejemplo, clase Ejecutable inusual con el siguiente código:
Runnable r = new Runnable() {
@Override
public void run() {
//to do something
}
};
Thread t = new Thread(r);
t.start();Use Lambda expresiones:
Runnable r = () -> {
//to do something
};
Thread t = new Thread(r);
t.start();O utilizar una forma más compacta:
new Thread(()->System.out.println("run thread...")).start();referencias
Los escenarios comunes de Java expresiones Lambda
