Comenzando con las expresiones Lambda, ¡este artículo es suficiente!

Autor: Source to Sea: www.cnblogs.com/haixiang/p/11029639.html

Introducción a Lambda

Las expresiones Lambda son una nueva característica de JDK8, que puede reemplazar la mayoría de las clases internas anónimas y escribir código Java más elegante, especialmente en el recorrido de colecciones y otras operaciones de colección, que pueden optimizar en gran medida la estructura del código.

JDK también proporciona una gran cantidad de interfaces funcionales integradas para que las usemos, lo que hace que el uso de expresiones Lambda sea más conveniente y eficiente.

Requisitos para la interfaz

Aunque algunas interfaces se pueden implementar fácilmente mediante expresiones Lambda, no todas las interfaces se pueden implementar mediante expresiones Lambda. Lambda estipula que solo puede haber un método en la interfaz que deba implementarse, no que solo pueda haber un método en la interfaz

Hay otra característica nueva en jdk 8: default , el método modificado por defecto tendrá una implementación predeterminada, que no es un método que deba implementarse, por lo que no afecta el uso de expresiones Lambda.

@FunctionalInterface

La modificación de una interfaz funcional requiere solo un método abstracto en la interfaz. Esta anotación a menudo aparece junto con expresiones lambda .

Sintaxis básica de Lambda

Aquí damos seis interfaces, y todas las operaciones a continuación utilizarán estas seis interfaces para explicar.

/**多参数无返回*/
@FunctionalInterface
public interface NoReturnMultiParam {
    void method(int a, int b);
}

/**无参无返回值*/
@FunctionalInterface
public interface NoReturnNoParam {
    void method();
}

/**一个参数无返回*/
@FunctionalInterface
public interface NoReturnOneParam {
    void method(int a);
}

/**多个参数有返回值*/
@FunctionalInterface
public interface ReturnMultiParam {
    int method(int a, int b);
}

/*** 无参有返回*/
@FunctionalInterface
public interface ReturnNoParam {
    int method();
}

/**一个参数有返回值*/
@FunctionalInterface
public interface ReturnOneParam {
    int method(int a);
}

La sintaxis es () -> {}, donde () se usa para describir la lista de parámetros, {} se usa para describir el cuerpo del método, -> es el operador lambda, pronunciado (va a).

import lambda.interfaces.*;

public class Test1 {
    public static void main(String[] args) {

        //无参无返回
        NoReturnNoParam noReturnNoParam = () -> {
            System.out.println("NoReturnNoParam");
        };
        noReturnNoParam.method();

        //一个参数无返回
        NoReturnOneParam noReturnOneParam = (int a) -> {
            System.out.println("NoReturnOneParam param:" + a);
        };
        noReturnOneParam.method(6);

        //多个参数无返回
        NoReturnMultiParam noReturnMultiParam = (int a, int b) -> {
            System.out.println("NoReturnMultiParam param:" + "{" + a +"," + + b +"}");
        };
        noReturnMultiParam.method(6, 8);

        //无参有返回值
        ReturnNoParam returnNoParam = () -> {
            System.out.print("ReturnNoParam");
            return 1;
        };

        int res = returnNoParam.method();
        System.out.println("return:" + res);

        //一个参数有返回值
        ReturnOneParam returnOneParam = (int a) -> {
            System.out.println("ReturnOneParam param:" + a);
            return 1;
        };

        int res2 = returnOneParam.method(6);
        System.out.println("return:" + res2);

        //多个参数有返回值
        ReturnMultiParam returnMultiParam = (int a, int b) -> {
            System.out.println("ReturnMultiParam param:" + "{" + a + "," + b +"}");
            return 1;
        };

        int res3 = returnMultiParam.method(6, 8);
        System.out.println("return:" + res3);
    }
}

Simplificación de la sintaxis lambda

Podemos simplificar aún más el código observando el siguiente código y escribiendo un código más elegante.

import lambda.interfaces.*;

public class Test2 {
    public static void main(String[] args) {

        //1.简化参数类型，可以不写参数类型，但是必须所有参数都不写
        NoReturnMultiParam lamdba1 = (a, b) -> {
            System.out.println("简化参数类型");
        };
        lamdba1.method(1, 2);

        //2.简化参数小括号，如果只有一个参数则可以省略参数小括号
        NoReturnOneParam lambda2 = a -> {
            System.out.println("简化参数小括号");
        };
        lambda2.method(1);

        //3.简化方法体大括号，如果方法条只有一条语句，则可以胜率方法体大括号
        NoReturnNoParam lambda3 = () -> System.out.println("简化方法体大括号");
        lambda3.method();

        //4.如果方法体只有一条语句，并且是 return 语句，则可以省略方法体大括号
        ReturnOneParam lambda4 = a -> a+3;
        System.out.println(lambda4.method(5));

        ReturnMultiParam lambda5 = (a, b) -> a+b;
        System.out.println(lambda5.method(1, 1));
    }
}

Ejemplos comunes de expresiones lambda

Método de referencia de expresión lambda

A veces no tenemos que reescribir el método de una clase interna anónima por nosotros mismos, podemos usar la interfaz de expresión lambda para apuntar rápidamente a un método ya implementado. Siga la respuesta de la pila de tecnología Java del número público para obtener la serie de tutoriales Java8 que escribí.

gramática

Propietario del método :: nombre del método El propietario del método estático es el nombre de la clase, el propietario del método ordinario es el objeto

public class Exe1 {
    public static void main(String[] args) {
        ReturnOneParam lambda1 = a -> doubleNum(a);
        System.out.println(lambda1.method(3));

        //lambda2 引用了已经实现的 doubleNum 方法
        ReturnOneParam lambda2 = Exe1::doubleNum;
        System.out.println(lambda2.method(3));

        Exe1 exe = new Exe1();

        //lambda4 引用了已经实现的 addTwo 方法
        ReturnOneParam lambda4 = exe::addTwo;
        System.out.println(lambda4.method(2));
    }

    /**
     * 要求
     * 1.参数数量和类型要与接口中定义的一致
     * 2.返回值类型要与接口中定义的一致
     */
    public static int doubleNum(int a) {
        return a * 2;
    }

    public int addTwo(int a) {
        return a + 2;
    }
}

Referencia del método de construcción

Generalmente necesitamos declarar una interfaz, que actúa como un generador de un objeto, crea una instancia del objeto mediante el nombre de la clase :: new, y luego llama a un método para devolver el objeto.

interface ItemCreatorBlankConstruct {
    Item getItem();
}
interface ItemCreatorParamContruct {
    Item getItem(int id, String name, double price);
}

public class Exe2 {
    public static void main(String[] args) {
        ItemCreatorBlankConstruct creator = () -> new Item();
        Item item = creator.getItem();

        ItemCreatorBlankConstruct creator2 = Item::new;
        Item item2 = creator2.getItem();

        ItemCreatorParamContruct creator3 = Item::new;
        Item item3 = creator3.getItem(112, "鼠标", 135.99);
    }
}

expresión lambda crea hilo

Solíamos crear objetos Thread y luego reescribir el método run () a través de clases internas anónimas.Cuando mencionamos clases internas anónimas, debemos pensar que podemos usar expresiones lambda para simplificar el proceso de creación de subprocesos.

ArrayList<Integer> list = new ArrayList<>();

Collections.addAll(list, 1,2,3,4,5);

//lambda表达式 方法引用
list.forEach(System.out::println);

list.forEach(element -> {
  if (element % 2 == 0) {
    System.out.println(element);
  }
});

Eliminar un elemento de la colección

Usamos public boolean removeIf(Predicate<? super E> filter)métodos para eliminar un elemento de la colección. Predicate es también una interfaz funcional proporcionada por jdk, que puede simplificar la escritura del programa.

ArrayList<Item> items = new ArrayList<>();
items.add(new Item(11, "小牙刷", 12.05 ));
items.add(new Item(5, "日本马桶盖", 999.05 ));
items.add(new Item(7, "格力空调", 888.88 ));
items.add(new Item(17, "肥皂", 2.00 ));
items.add(new Item(9, "冰箱", 4200.00 ));

items.removeIf(ele -> ele.getId() == 7);

//通过 foreach 遍历，查看是否已经删除
items.forEach(System.out::println);

Clasificación de elementos de la colección

En el pasado, si queríamos ordenar los elementos de la colección, teníamos que llamar al método sort y pasar la clase interna anónima del comparador para anular el método de comparación. Ahora podemos usar expresiones lambda para simplificar el código.

ArrayList<Item> list = new ArrayList<>();
list.add(new Item(13, "背心", 7.80));
list.add(new Item(11, "半袖", 37.80));
list.add(new Item(14, "风衣", 139.80));
list.add(new Item(12, "秋裤", 55.33));

/*
list.sort(new Comparator<Item>() {
    @Override
    public int compare(Item o1, Item o2) {
        return o1.getId()  - o2.getId();
    }
});
*/

list.sort((o1, o2) -> o1.getId() - o2.getId());

System.out.println(list);

Problemas de cierre en expresiones lambda

Este problema también existe en las clases internas anónimas. Si ponemos el comentario en la reunión e informamos un error, dígame que el valor num es final y no se puede cambiar. Aunque no marcamos el tipo num como final, la máquina virtual nos ayudó a agregar palabras clave modificadas finales durante la compilación.

import java.util.function.Consumer;
public class Main {
    public static void main(String[] args) {

        int num = 10;

        Consumer<String> consumer = ele -> {
            System.out.println(num);
        };

        //num = num + 2;
        consumer.accept("hello");
    }
}

Artículos calientes recientes recomendados:

1. ¡ 6 formas de obtener el código de activación de IntelliJ IDEA gratis!

2. Usé Java 8 para escribir una pieza de lógica y mis colegas no pudieron entenderla directamente, puedes probarla. .

3. Sling Tomcat, ¡el rendimiento de Undertow es muy explosivo! !

4. Los chinos abrieron un cliente de Redis súper fácil de usar, ¡que es tan fragante! !

5. La última versión del "Manual de desarrollo de Java (edición Songshan)", ¡descárguela rápidamente!

¡Siéntete bien, no olvides dar me gusta + reenviar!

¡Siéntete bien, no te olvides de dar me gusta + reenviar!

Finalmente, preste atención a la cuenta oficial de WeChat del líder de la pila: pila de tecnología Java, responda: Bienestar, puede obtener una copia gratuita de las últimas preguntas de la entrevista de Java que he compilado para 2020. Es realmente completo (incluidas las respuestas), sin ninguna rutina.