Java 8's Lambda expressions make the code more concise by simplifying the anonymous internal class implementation. 1. The basic syntax is (parameter list) -> { method body}, such as Runnable r = () -> System.out.println("Hello"); 2. It is often used for collection traversal and sorting, such as names.forEach(name -> System.out.println(name)) and numbers.sort((a, b) -> a.compareTo(b)); 3. It can only be used for functional interfaces, that is, interfaces with only one abstract method, such as Runnable, Supplier, Consumer, Function, Predicate; 4. The scope of the variable must be final or effectively final, this points to the outer object. Lambda is very practical in handling collections, event listening, and thread tasks, improving development efficiency.

Java 8 introduces Lambda expressions to make the code more concise and readable. If you have written many anonymous internal classes before to implement single-method interfaces (such as Runnable or Comparator ), you will find that Lambda can greatly reduce boilerplate code.

The following sections will explain clearly how to use Lambda expressions, which are suitable for those who are new to Java 8.

Understand the basic syntax of Lambda

The structure of a Lambda expression is actually very simple:
(參數(shù)列表) -> { 方法體}

Let's give the simplest example:

 // Traditional writing method Runnable r = new Runnable() {
    public void run() {
        System.out.println("Hello");
    }
};

// Using Lambda
Runnable r = () -> System.out.println("Hello");

A few points to note:

• If there are no parameters, brackets cannot be saved.
• If there is only one statement, you can not write {} and return (if it is the case of return value).
• If there are multiple statements, it must be wrapped in {} , and if there is a return value, add return .

Common usage scenarios: collection traversal and sorting

One of the most common uses of Lambda is to simplify collection operations. For example, you want to traverse or sort a List:

Traversal List

 List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

// This used to be for (String name : names) {
    System.out.println(name);
}

// Lambda writing method names.forEach(name -> System.out.println(name));

The forEach method is used here. The passed parameters are an implementation of a Consumer interface, and Lambda is used to implement it.

Sort List

 List<Integer> numbers = Arrays.asList(5, 2, 8, 1);

// Previous practices Collections.sort(numbers, new Comparator<Integer>() {
    public int compare(Integer a, Integer b) {
        return a.compareTo(b);
    }
});

// Lambda version numbers.sort((a, b) -> a.compareTo(b));

Here (a, b) are two parameters, -> is followed by an expression that returns the comparison result. This writing is clear and concise.

Functional interface is the basis of Lambda

Lambda can only be used for functional interfaces - that is, interfaces with only one abstract method. Java 8 provides some commonly used functional interfaces, such as:

• Runnable (no parameters, no return)
• Supplier<T> (no parameter returns)
• Consumer<T> (with parameters but no return)
• Function<T, R> (with parameters and return)
• Predicate<T> (Judgement Conditions)

You can define the functional interface yourself, just make sure it has only one abstract method, or add @FunctionalInterface annotation to clarify this intention.

For example:

 @FunctionalInterface
interface MathOperation {
    int operate(int a, int b);
}

Then you can implement it with Lambda like this:

 MathOperation add = (a, b) -> ab;
MathOperation multiply = (a, b) -> a * b;

Pay attention to variable scope and this keywords

Two things to note when using external variables in Lambda:

• You can access final variables or variables equivalent to final (that is, they will not change after assignment).
• this in a Lambda expression points to a peripheral object, not the Lambda itself (this is different from anonymous classes).

for example:

 int factor = 2;
List<Integer> list = Arrays.asList(1, 2, 3);

list.forEach(item -> {
    int result = item * factor; // No problem here, because factor is effectively final
    System.out.println(result);
});

But if you try to modify factor , the compiler will report an error.

Basically that's it. Although Lambda expressions seem simple, they are very practical in actual development, especially in handling collections, event listening, thread tasks, etc. I may not be used to it at first, so I will be able to write a few more times.

The above is the detailed content of Implementing Lambda Expressions in Java.. For more information, please follow other related articles on the PHP Chinese website!