Let's test and learn the understanding of Lambda expressions in Java

Chat:

It’s been a long time since JDK8 came out. I got to know it a little bit when it first came out, then discarded it, and now I’m picking it up again. Although it is now JDK11.

This article will be in continuous update mode.

Text:

Look at the code directly. In the new features of java8, we can write like this:

public static void main(String[] args) {
        Supplier<Integer> supplier = ()->1;
        Consumer<String> consumer = (a)-> System.out.println(a);
        System.out.println(supplier.get());
        consumer.accept("test");
    }

Output:

1
test

Process finished with exit code 0

is very fashionable. Can you do such a concise code? I mean you java7

First steal a picture and explain Lambda

In other words, Lambda expression, creates an implementation of the corresponding interface, and then assigns it to the variable . Is it using the compiler? Check the compiled code as follows:

public static void main(String[] args) {
        Supplier<Integer> supplier = () -> {
            return 1;
        };
        Consumer<String> consumer = (a) -> {
            System.out.println(a);
        };
        System.out.println(supplier.get());
        consumer.accept("test");
    }

The compiler does not do this function, so it may be that the JVM has implemented the Lambda function. We will learn more about it later. Mark 1

Written here, you can know that Lambda expressions reduce the amount of code. Before Java8, you could only use anonymous inner classes or create a class to implement the interface to achieve this function. As follows

Supplier<Integer> supplier = new Supplier<Integer>() {
            @Override
            public Integer get() {
                return 1;
            }
        };

Actually, I am more curious about the interfaces accompanying Lambda. Open the source code and you can see

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

对应的接口都添加了注解FunctionalInterface，那么不要这个注解是否能实现Lambda表达式，我做了一些测试，发现不需要注解也可以实现，目前来看注解只有两个功能 
1、表示这个接口是函数式接口 2、帮助编译器识别，接口不能有多个方法。
在有多个方法的时候会提示Multiple non-overriding abstract methods found in interface

Now we can use FunctionalInterface to find out which interfaces are functional interfaces in JDK8

I chose one or two of the more popular ones to test and learn

Oh, let me interrupt first and I saw a very important passage when I just read the article (in In practice, functional interfaces are very fragile: as long as a developer adds a function to the interface, the interface is no longer a functional interface and compilation fails. In order to overcome this fragility at the code level, and explicitly Indicate that an interface is a functional interface. Java 8 provides a special annotation)

I chose two classes: ArrayList and Optional, both of which are very commonly used classes.

Related articles:

In-depth understanding of Lambda expressions in Java

A preliminary exploration of Java Lambda expressions

Related videos:

JavaScript Regular Expression Video Tutorial

---

The above is the detailed content of Let's test and learn the understanding of Lambda expressions in Java. For more information, please follow other related articles on the PHP Chinese website!