Conceptos básicos de expresión lambda aprendidos recientemente

Prefacio

Solo una cabeza calva puede volverse más fuerte.
El texto se ha incluido en mi repositorio de GitHub, bienvenido a Star: https://github.com/ZhongFuCheng3y/3y
Fui a Shanghai durante el Festival del Medio Otoño y marqué una tarjeta en el Bund:

Luego, el Bund aprendió sobre programación funcional en Java, lo resolvió para todos y ¡estudiaron juntos!

Uno, uso de Lambda

Cuando escribí la clase Opcional antes, hablé brevemente sobre cómo se usa Lambda. Aquí hay una revisión con usted. La sintaxis de Lambda es así:

La sintaxis
para crear un hilo para distinguir la sintaxis Lambda para crear hilos y clases internas anónimas (¡el código es claramente mucho menos!):

public static void main(String[] args) {
    // 用匿名内部类的方式来创建线程
    new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("公众号：Java3y---关注我！");
        }
    });

    // 使用Lambda来创建线程
    new Thread(() -> System.out.println("公众号：Java3y---关注我！"));
}

El uso de expresiones Lambda en realidad crea un objeto de instancia de la interfaz.

Devuelve un
icono de instancia de objeto Runnable ; la interfaz Runnable como ejemplo:

Tomando la interfaz Runnable como ejemplo, el
uso de expresiones Labmda requiere una interfaz de programación funcional. Por ejemplo, en la interfaz Runnable podemos ver la anotación @FunctionalInterface (marcando que esta interfaz tiene solo un método abstracto)

La interfaz de programación funcional tiene solo un método abstracto

1.1 Interfaz de programación funcional

Como se puede ver en el ejemplo de código anterior, cuando usamos expresiones Lambda para crear subprocesos, no nos importan los nombres de las interfaces, los nombres de los métodos y los nombres de los parámetros. Solo prestamos atención a sus tipos de parámetros, la cantidad de parámetros y el valor de retorno.

JDK nos proporciona de forma nativa algunas interfaces de programación funcional para que las usemos, las siguientes son algunas interfaces de uso común:

Una
breve descripción de las interfaces de programación funcional de uso común :

• La interfaz unaria en la tabla significa que solo hay un parámetro de
  
  entrada , y la interfaz binaria significa que hay dos parámetros de entrada . Tome BiFunction como ejemplo de la
  
  interfaz funcional de uso común
  Demostración:

// Consumer 一个入参，无返回值
Consumer<String> consumer = s-> System.out.println(s);
consumer.accept("Java3y");

// Supplier 无入参，有返回值
Supplier<String> supplier = () -> "Java4y";
String s = supplier.get();
System.out.println(s);

//.....

Al usar Lambda, hay dos cosas que recordar:

1. Lambda devuelve un objeto de instancia de la interfaz
2. ¿Hay algún parámetro, cuántos parámetros hay, si hay un valor de retorno, cuál es el tipo de valor de retorno -> elija su propia interfaz funcional adecuada

   1.2 Referencia de método

Al aprender Lambda, también puede encontrar una forma extraña de escribir, como el siguiente código:

// 方法引用写法
Consumer<String> consumer = System.out::println;
consumer.accept("Java3y");

Si sigue la escritura normal de Lambda, puede ser así:

// 普通的Lambda写法
Consumer<String> consumer = s -> System.out.println(s);
consumer.accept("Java3y");

Obviamente, el uso de referencias a métodos es un poco más conciso que las expresiones Lambda ordinarias.

Si la implementación de la interfaz funcional se logra llamando a un método, entonces podemos usar la referencia del método

La realización de la interfaz funcional puede ocurrir llamando a un método para realizar la
referencia del método y hay varios tipos:

• Referencias de métodos para métodos estáticos
• Referencias de métodos para métodos no estáticos
• La referencia al método de la referencia al método del constructor
  Demo:

public class Demo {
    public static void main(String[] args) {
        // 静态方法引用--通过类名调用
        Consumer<String> consumerStatic = Java3y::MyNameStatic;
        consumerStatic.accept("3y---static");

        //实例方法引用--通过实例调用
        Java3y java3y = new Java3y();
        Consumer<String> consumer = java3y::myName;
        consumer.accept("3y---instance");

        // 构造方法方法引用--无参数
        Supplier<Java3y> supplier = Java3y::new;
        System.out.println(supplier.get());
    }
}

class Java3y {
    // 静态方法
    public static void MyNameStatic(String name) {
        System.out.println(name);
    }

    // 实例方法
    public void myName(String name) {
        System.out.println(name);
    }

    // 无参构造方法
    public Java3y() {
    }
}

Los resultados son los siguientes:

resultado

Al final

Aunque el código de Lambda parece conciso, es difícil de entender si es complicado.

Al aprender Lambda, primero debemos saber cuáles son las interfaces de programación funcional de uso común y cuáles son las diferencias entre estas interfaces de programación funcional (número de parámetros, tipos de valor de retorno)

Las expresiones Lambda devuelven una instancia de un objeto de interfaz. Si la implementación de una interfaz funcional se logra llamando a un método, entonces podemos usar referencias de método en lugar de expresiones Lambda.

Finalmente, dé un ejemplo completo:

// Supplier是一个无入参带返回的值的函数式编程接口

// () -> new Java3y()这整句Lambda表达式，返回的是Supplier接口的实例。从Lambda表达式可以看出无参数，带返回值
Supplier<Java3y> supplier = () -> new Java3y(); 

// 由于这个“() -> new Java3y()”Lambda表达式可以通过调用一个方法就实现了，那么我们可以优化成方法引用
Supplier<Java3y> supplier2 = Java3y::new;

Navegación de artículos de números públicos: ¡dos años de arduo trabajo!

Más de 200 artículos originales artículos técnicos
recursos de video masivos
mapa mental exquisito
preguntas de la cara
prensa escanear código puede estar preocupado por obtener
ver y compartir es muy importante para mí!