What are the uses of Lambda expressions in Java?

Lambda expression:

1. Introduction

First of all, Lambda expression belongs toJava8 A new feature of provides support for functional programming in Java programming, which helps to simplify the code and can replace most of the anonymous functions. Especially for collection traversal and collection operations, it greatly simplifies the code. .

The body of the Lambda expression:

##Functional interface:

Note: Lambda expressions must be used with functional interfaces. The so-called functional interface is an interface with only one abstract method in the interface. It is a functional interface. We can customize it. JDK also has a large number of built-in functions. interface.

1. @FunctionalInterface annotation modifies the interface, then this interface is a functional interface, which can only have one method. The following is a functional interface:

@FunctionalInterface
public interface MyInteface {
    void eat();
}

2, If you do not add the @FunctionalInterface** annotation, you can also think of it as a functional interface if you only write an abstract method in the interface:

public interface MyInteface {
    void eat();
}

This is also possible.

3, Functional interface only has one situation where does not only have abstract methods, that is, methods that can inherit the Object class:

@FunctionalInterface
public interface MyInteface3 {
    void eat();
    @Override
    String toString();
    @Override
    int hashCode();
}

2, Use of Lambda expressions:

1. Use in ordinary methods

Student class:

@FunctionalInterface
public interface Student {
    void eat();
}

Test class:

public class Test {
    public static void main(String[] args) {
        Student stu = new Student() {
            //普通方法，重写并使用
            @Override
            public void eat() {
                System.out.println("我是学生");
            }
        };
        stu.eat();

        //lambda表达式写法：
        //参数1:重写了Student接口中唯一的那个无参数的eat抽象方法做了具体的实现，所以重写不 需要署名
        //参数2:-> 表达式 固定的
        //参数3：{具体的实现} 对Student接口中唯一的eat方法做了具体的实现
            Student stu2 = () -> {
                System.out.println("学生吃饭");
            };
        stu2.eat();
    }
}

Output:

I am a student

Students eat

2. Use of parameter method

Student class:

@FunctionalInterface
public interface Student {
    void eat(String food);
}

Test class:

public class Test {
    public static void main(String[] args) {
        //lambda重写Student接口唯一的有参方法：
        Student stu2 = (foodName)->{
            System.out.println("学生在吃"+foodName);
        };
        stu2.eat("肉");
    }
}
//输出：学生在吃肉

3. Lambda expression to implement multi-threading

In the previous article on multi-threading (1), the method of creating multi-threads was introduced. Here we use lambda to create threads:

public class Test {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("这个线程是由lambda来创建的");
        });
        t.start();
    }
}

4. Lambda expression operation operation

We can use lambda to operate with a lot less code:

Functional interface:

@FunctionalInterface
public interface Calculator<T> {
    T operation(T v1,T v2);
}

Test class:

public class Test {
    //计算方法
    public static Integer operator(Integer v1,Integer v2,Calculator<Integer> calculator){
        return calculator.operation(v1, v2);
    }
    public static void main(String[] args) {

        //使用lambda表达式：
        //这里的意思就是传入两个参数，返回运行后的值
        int add = Test.operator(5,10,(x,y)->{
            return x+y;
        });

        //简写：可以少写很多代码，比上面更简介了
        int num1 = Test.operator(5,10,(x,y)->x+y);
        int num2 = Test.operator(10,5,(x,y)->x-y);
        System.out.println(add);
        System.out.println(num1);
        System.out.println(num2);
    }
}

Output:

15, 15, 5

5, Lambda expression method reference

Sometimes we don’t have to To rewrite the methods of the interface for specific implementation, if we have existing methods that can be implemented, we can also refer to the existing methods through method references to implement specific implementations of the methods in the interface. The advantage of this is code reuse. , such as the following:

Functional interface:

public interface ResultOneParam {
    int method(int a);
}

Test class:

public class Test {
    public int addTo(int a){
        return  a+10;
    }
    public  static int addTo2(int a){
        return  a+10;
    }
    public static void main(String[] args) {
        //lambda重写了method方法
        ResultOneParam lambda1=(a)->a+10;
        //方法引用：就是在Test里面的addTo2方法用来替代method被重写的方法
        ResultOneParam lambda2= Test::addTo2;
        int result1= lambda2.method(9);
        System.out.println(result1);
        //方法引用 ::引用现成的方法来替代方法重写，这样可以方法重用
        Test test=new Test();
        ResultOneParam lambda3=test::addTo;
        int result2= lambda3.method(9);
        System.out.println(result1);
    }
}

6. Lambda expression pair The use of collections

Of course Lambda is also very convenient to operate collections, which can save a lot of code:

public class Test {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(5,1,3,4,5,0,9,7,0,1,5);
        //lambda表达式遍历集合，重写了Consumer接口的方法
        list.forEach((element)->{
            System.out.println(element);
        });
        //简写：
        list.forEach(element-> System.out.println(element));
        //lambda表达式方法引用，用于遍历输出list集合:
        list.forEach(System.out::print);
        //输出list的偶数:
        list.forEach(element->{
            if(element%2==0){
                System.out.println(element);
            }
        });
    }
}

The above is the detailed content of What are the uses of Lambda expressions in Java?. For more information, please follow other related articles on the PHP Chinese website!