(1) What is a lambda expression

1 What is? Lambda expression

Runnable Interface

@FunctionalInterface //  The interface modified by this annotation can only declare one abstract method 
public interface Runnable {
    
    public abstract void run();
}

The code structure

new Thread(new Runnable() {
    
            @Override
            public void run() {
    
                System.out.println(" Code executed in a new thread  :"+Thread.currentThread().getName());
            }
        }).start();//  Not with lambda Writing method of creating thread 

Take the above code as an example ：

• We all know You cannot call the interface directly To touch is the class implementation interface Then instantiate the calling method
• Or use it directly Anonymity class class The way Lambda Is to simplify the writing of anonymous classes and classes
• The traditional way It is generally used The above code Or similar

Use Lambda simplify

Of course, it can also be more simplified It will be described in detail below

new Thread(() ->{
    
            System.out.println(" Code executed in a new thread  :"+Thread.currentThread().getName());
        }).start();

2 Lambda Grammatical rules

Lambda No object-oriented rules ,Lambda The standard format for is provided by 3 Component composition ：

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

Format specification ：

• ( Parameter type Parameter name ): parameter list
• { Code body ;} : Method body
• ->: arrow , Split parameter list and method body

Simple exercises ：

• No arguments

public class Demo1Lambda {
    
    public static void main(String[] args) {
    
          //  Start a new thread 
        new Thread(new Runnable() {
    
            @Override
            public void run() {
    
                System.out.println(" Code executed in a new thread  :"+Thread.currentThread().getName());
            }
        }).start();//  Not with lambda Writing method of creating thread 
        
        new Thread(() ->{
     //  Call a parameterless method 
            System.out.println(" Code executed in a new thread  :"+Thread.currentThread().getName());
        }).start();
        System.out.println(" Code in the main thread ：" + Thread.currentThread().getName());
    }
}

3 @FunctionalInterface annotation

/** * @FunctionalInterface *  This is a logo annotation , The interface modified by this annotation can only declare one abstract method  *  Multiple compilers fail  */
@FunctionalInterface
public interface UserService {
    
void show();
}

4 Lambda The omission of expressions

stay lambda Based on the standard writing of expressions , The rule that you can use ellipsis is ：

1. Parameter types in parentheses can be omitted
2. If there is only one parameter in the parenthesis , Then brackets can be omitted
3. If there is and only one statement in braces , You can omit braces at the same time ,return Keywords and statement semicolons .

Interface

public interface StudentService {
    
    String show(String name, Long id) ;
}

Code implementation

 public static void main(String[] args) {
    
     	goStudent((String name,Long id) ->{
    
            return name+id;
        });
     	// lambda Simplified code 
        goStudent((String name,Long id) -> name+id+666);
    }

	//  Custom methods 
    public static void goStudent(StudentService studentService){
    
        System.out.println(studentService.show(" Zhang San ", 22L));
    }

• Generally, we will base on the readability of the code Moderate simplification

5 Lambda The premise of expression

Lambda The syntax of expressions is very simple , however Lambda Expressions are not random , There are several conditions to pay special attention to when using
It means

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

6 Lambda Compared to anonymous inner classes

Lambda Compared to anonymous inner classes

1. The types of scenarios used are different
   • The type of anonymous inner class can be class , abstract class , Interface
   • Lambda The type required for an expression must be an interface
2. The number of abstract methods is different
   • The number of abstract methods in the interface required by anonymous inner classes is arbitrary
   • Lambda An expression requires only one abstract method in the interface
3. The implementation principle is different
   • Anonymous inner classes are compiled to form a class
   • Lambda The expression is when the program is running Dynamic generation class