Lambda expression principles and examples

Lambda Expressions

Lambda expressions, also known as closures, are the most important new feature that drove the release of Java 8.
Lambda allows a function to be used as a method parameter (a function is passed into a method as a parameter).
Using Lambda expressions can make the code more concise and compact.

1. Demand Analysis

Create a new thread and specify the task to be performed by the thread

    public static void main(String[] args) {
        // Start a new thread new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Code executed in the new thread: "+Thread.currentThread().getName());
            }
        }).start();
        System.out.println("Code in the main thread: " + Thread.currentThread().getName());
    }

Code Analysis:

1. The Thread class requires a Runnable interface as a parameter, in which the abstract method run is the core method used to specify the thread task content.
2. In order to specify the run method body, you have to use the Runnable implementation class
3. In order to save the definition of a Runnable implementation class, you have to use an anonymous inner class
4. The abstract run method must be overridden and rewritten. All method names, method parameters, and method return values ​​must be rewritten without error.
5. In fact, we only care about the code in the method body

2. Lambda Expressions for Beginners

Lambda expression is an anonymous function, which can be understood as a piece of code that can be passed

new Thread(() -> { System.out.println("New thread Lambda expression..." +Thread.currentThread().getName()); })
.start();
Advantages of Lambda expressions: Simplifies the use of anonymous inner classes and has simpler syntax.

The syntax of anonymous inner classes is redundant. After experiencing Lambda expressions, I found that Lambda expressions are a way to simplify anonymous inner classes.

3. Lambda syntax rules

Lambda eliminates the object-oriented rules and regulations. The standard format of Lambda consists of three parts:

(parameter type parameter name) -> {
Code body;
}

Format description:

• (parameter type parameter name): parameter list
• {code body;} : method body
• -> : Arrow, separating parameter list and method body

3.1 Lambda Exercise 1

Practice Lambda with no parameters and no return value

Defining an interface

public interface UserService {
    void show();
}

Then create the main method using

public class Demo03Lambda {

    public static void main(String[] args) {
        goShow(new UserService() {
            @Override
            public void show() {
                System.out.println("show method executed...");
            }
        });
        System.out.println("----------");
        goShow(() -> { System.out.println("Lambda show method executed..."); });
    }

    public static void goShow(UserService userService){
        userService.show();
    }
}

Output:

The show method executes...
----------
The Lambda show method executes...

3.2 Lambda Exercise 2

Complete a Lambda expression case with parameters and return value

Creating a Person Object

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person {

    private String name;

    private Integer age;

    private Integer height;

}

Then we save multiple Person objects in the List collection, and then sort these objects according to age.

    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("Jay Chou",33,175));
        list.add(new Person("Andy Lau",43,185));
        list.add(new Person("周星驰",38,177));
        list.add(new Person("郭富城",23,170));

        Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge()-o2.getAge();
            }
        });
        for (Person person : list) {
            System.out.println(person);
        }
    }

We found that the second parameter of the sort method is an anonymous inner class of the Comparator interface, and the executed method has parameters and return values, so we can rewrite it as a Lambda expression

    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("Jay Chou",33,175));
        list.add(new Person("Andy Lau",43,185));
        list.add(new Person("周星驰",38,177));
        list.add(new Person("郭富城",23,170));

        /*Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge()-o2.getAge();
            }
        });
        for (Person person : list) {
            System.out.println(person);
        }*/
        System.out.println("------");
        Collections.sort(list,(Person o1,Person o2) -> {
            return o1.getAge() - o2.getAge();
        });
        for (Person person : list) {
            System.out.println(person);
        }
    }

Output

Person(name=Aaron Kwok, age=23, height=170)
Person(name=Jay Chou, age=33, height=175)
Person(name=周星驰, age=38, height=177)
Person(name=Andy Lau, age=43, height=185)

4. @FunctionalInterface annotation

@FunctionalInterface is a new functional annotation added in JDK8, indicating that the interface modified by this annotation can only have one abstract method.

/**
 * @FunctionalInterface
 * This is a functional annotation. The interface modified by this annotation can only declare one abstract method*/


@FunctionalInterface
public interface UserService {

    void show();

}

5. The principle of Lambda expression

The essence of an anonymous inner class is to generate a Class file during compilation. XXXXX$1.class

public class Demo01Lambda {

    public static void main(String[] args) {
        // Start a new thread new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Code executed in the new thread: "+Thread.currentThread().getName());
            }
        }).start();
        System.out.println("Code in the main thread: " + Thread.currentThread().getName());
        System.out.println("---------------");
        /*new Thread(() -> { System.out.println("New thread Lambda expression..." +Thread.currentThread().getName()); })
                .start();*/
    }
}

You can also use the decompilation tool to view the generated code XJad tool to view

static class Demo01Lambda$1
 implements Runnable
{

 public void run()
 {
  System.out.println((new StringBuilder()).append("Code executed in the new thread: " ).append(Thread.currentThread().getName()).toString());
 }

 Demo01Lambda$1()
 {
 }
}

So what is the principle of Lambda expression? We also use the decompilation tool to check

For class files with Lambda expressions, we use XJad to check errors. At this time, we can use a tool that comes with JDK: javap to disassemble the bytecode.

javap -c -p filename.class

• -c: means disassembling the code
• -p: Display all classes and members

The result of disassembly:

E:\workspace\OpenClassWorkSpace\JDK8Demo\target\classes\com\bobo\jdk\lambda>javap -c -p Demo03Lambda.class
Compiled from "Demo03Lambda.java"
public class com.bobo.jdk.lambda.Demo03Lambda {
  public com.bobo.jdk.lambda.Demo03Lambda();
    Code:
       0: aload_0
       1: invokespecial #1 // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: invokedynamic #2, 0 // InvokeDynamic #0:show:()Lcom/bobo/jdk/lambda/service/UserService;
       5: invokestatic #3 // Method goShow:(Lcom/bobo/jdk/lambda/service/UserService;)V
       8: return

  public static void goShow(com.bobo.jdk.lambda.service.UserService);
    Code:
       0: aload_0
       1: invokeinterface #4, 1 // InterfaceMethod com/bobo/jdk/lambda/service/UserService.show:()V
       6: return

  private static void lambda$main$0();
    Code:
       0: getstatic #5 // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc #6 // String Lambda show method executes...
       5: invokevirtual #7 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return
}

In this decompiled source code, we see a static method lambda$main$0(). What does this method do? Let's check it out through debugging:

The above effect can be understood as follows:

public class Demo03Lambda {

    public static void main(String[] args) {
        ....
    }

    private static void lambda$main$0();
        System.out.println("Lambda show method executed...");
    }
}

To understand this more intuitively, we can add -Djdk.internal.lambda.dumpProxyClasses when running. Adding this parameter will output the internal class code to a file

java -Djdk.internal.lambda.dumpProxyClasses package name to be run. class name

Command Execution

E:\workspace\OpenClassWorkSpace\JDK8Demo\target\classes>java -Djdk.internal.lambda.dumpProxyClasses com.bobo.jdk.lambda.Demo03Lambda
The Lambda show method executes...

Decompiled content:

You can see that this anonymous inner class implements the UserService interface and overrides the show() method. In the show method, Demo03Lambda.lambda$main$0() is called, which means the content in Lambda is called.

public class Demo03Lambda {

    public static void main(String[] args) {
        goShow(new UserService() {
            @Override
            public void show() {
                Demo03Lambda.lambda$main$0();
            }
        });
        System.out.println("----------");
       
    }

    public static void goShow(UserService userService){
        userService.show();
    }

    private static void lambda$main$0();
        System.out.println("Lambda show method executed...");
    }
}

summary:

An anonymous inner class will generate a class file when compiled.

Lambda expressions form a class when the program runs.

1. A new method is added to the class. The method body of this method is the code in the Lambda expression.
2. It will also form an anonymous inner class, implement the interface, and override the abstract method
3. Overriding a method in an interface will call the newly generated method

6. Abbreviation of Lambda Expression

Based on the standard writing of lambda expressions, the rules for using ellipsis are as follows:

1. Parameter types in parentheses can be omitted
2. If there is only one parameter in the parentheses, the parentheses can be omitted.
3. If there is only one statement within the braces, the braces, return keyword and statement semicolon can be omitted.

public class Demo05Lambda {

    public static void main(String[] args) {
        goStudent((String name,Integer age)->{
            return name+age+" 6666 ...";
        });
        // Abbreviated form goStudent((name,age)-> name+age+" 6666 ...");
        System.out.println("------");
        goOrder((String name)->{
            System.out.println("--->" + name);
            return 666;
        });
        // Abbreviated notation goOrder(name -> {
            System.out.println("--->" + name);
            return 666;
        });
        goOrder(name -> 666);
    }

    public static void goStudent(StudentService studentService){
        studentService.show("张三",22);
    }

    public static void goOrder(OrderService orderService){
        orderService.show("Li Si");
    }
    
}

7. Prerequisites for using Lambda expressions

The syntax of Lambda expressions is very concise, but Lambda expressions cannot be used casually. There are several conditions that need special attention when using them.

1. The method parameter or local variable type must be an interface to use Lambda
2. There is only one abstract method in the interface (@FunctionalInterface)

8. Comparison between Lambda and anonymous inner classes

Comparison between Lambda and anonymous inner classes

1. The required types are different

• The type of anonymous inner class can be class, abstract class, interface
• The type required by the lambda expression must be an interface

2. The number of abstract methods is different

• The number of abstract methods in the interface required by the anonymous inner class is arbitrary.
• Lambda expressions require only one abstract method in the interface

3. The implementation principles are different

• An anonymous inner class forms a class after compilation
• Lambda expressions dynamically generate classes when the program is running.

This is the end of this article about the principles and examples of Lambda expressions. For more information about Lambda expressions, please search for previous articles on 123WORDPRESS.COM or continue to browse the following related articles. I hope you will support 123WORDPRESS.COM in the future!