How to understand lambda expressions in Java

This article brings you relevant knowledge about java, which mainly introduces issues related to lambda expressions. Lambda expressions are a new syntax form after the start of JDK8, which can Simplify the code writing of anonymous inner classes. Let’s take a look at it. I hope it will be helpful to everyone.

Recommended learning: "java video tutorial"

Lambda Overview

Lambda expression is a new syntax form after the start of JDK8

Function:Simplify the code writing of anonymous inner classes

Format:

(匿名内部类被重写方法的形参列表)->{
    被重写方法的方法体代码
}
注：->是语法形式，无实际意义

First we define an abstract class, rewrite its method through an anonymous inner class, then simplify it, and compare the changes between the two:

Before using Lambda expression:

public static void main (String[] args){
    People p = new People(){
    @Override
    public void run(){
        System.out.println("小学生跑的很慢");
        }
    };
    p.run();    

}
abstract class People{
    public abstract void run();
}

After using Lambda expression:

People p = ()->{
    System.out.println("小学生跑的很慢");
};
//会出现报错

An error will appear. Why is this? The reason is that the previous definition of Lambda expression is not clear. Lambda expression cannot simplify all anonymous inner classes. It can only simplify the writing form of anonymous inner classes in functional interfaces, and there are and only There is an abstract method . Usually, we will add a @Functionalinterface annotation on the interface to mark that the interface must satisfy the functional interface.

Really simplified through Lambda expression:

@FunctionalInterface//加上这个注解必须是函数式接口，且只有一个抽象方法
interface People{
    void run();
}
//简化之前的匿名内部类
People p = new People(){
    @Override
    public void run(){
        System.out.println("小学生跑的很慢！");
    }
};
//简化之后
People p = () -> {
        System.out.println("小学生跑的很慢！");
};

In addition, you can also substitute it as a parameter into the method to use:

//在原来的基础上定义一个pk方法
public static void pk(People p){
    System.out.println("跑步情况如何：")
    p.run();
}
//不使用Lambda的情况下：
pk(p);//需要在定义匿名内部类之后，将p代入；
//使用Lambda的情况：
People p = () -> {
        System.out.println("小学生跑的很慢！");
};
pk(() -> {
        System.out.println("小学生跑的很慢！");
});
//由于等号右边即是People创建的对象p，因此可以可以直接将其代入

Benefits of Lambda:

Lambda is an anonymous function. We can understand the Lambda expression as a piece of code that can be passed, which can write more Concise and more flexible code, as a more compact coding style, improves the expression ability of Java language.

The practical role of Lambda

In the previous learning process, we have learned the relevant knowledge of Arrays, including a sort method (which can arrange the array in ascending or descending order), It is actually an interface class and has only one abstract method:

//精简之前:
Arrays.sort(grade,new Comparator<Integer>(){
    @Override
    public int compare(Integer o1,Integer o2){
        return o2 -o1;
}
});
//精简之后:
Arrays.sort(grade,(Integer o1,Integer o2) -> {
        return o2 -o1;
});

Lambda expression omission rule

• The parameter type can be omitted

//参考前面的实战例子
Arrays.sort(grade,(Integer o1,Integer o2) -> {
        return o2 -o1;
});
//省略参数类型之后
Arrays.sort(grade,( o1, o2){
        return o2 -o1;
});

• If there is only one parameter, the parameter type can be omitted, and () can also be omitted

//简单引用一个单个参数的例子，不需要了解其具体含义
btn.addActionListener((ActionEvent e) -> {
    System.out.println("我是简单的例子。");
});
//简化之后：
btn.addActionListener( e -> {
    System.out.println("我是简单的例子。");
});

• If the method body code of the Lambda expression has only one line of code. You can omit the curly braces and omit the semicolon

//参照上一条规则的例子
btn.addActionListener( e -> {
    System.out.println("我是简单的例子。");
});
//简化之后：
btn.addActionListener( e -> System.out.println("我是简单的例子。") );

• if the method body code of the Lambda expression has only one line of code. You can omit the curly braces. At this time, if this line of code is a return statement, return must be omitted and ";" must be omitted.

//参照第一条规则的代码
Arrays.sort(grade,(Integer o1,Integer o2) -> {
        return o2 -o1;
});
//简化之后：
Arrays.sort(grade,( o1, o2)-> o2 -o1);

Recommended study: "java video tutorial"

The above is the detailed content of How to understand lambda expressions in Java. For more information, please follow other related articles on the PHP Chinese website!