Lambda expression

One 、 introduce lambda expression

Let's create a new thread , Then implement runable Interface run Method ：

public class demo1 {
    
    public static void main(String[] args) {
    
        new Thread(new Runnable() {
    
            @Override
            public void run() {
    
                System.out.println(" The new thread executes ...");
            }
        }).start();
    }
}

If you use lambda The expression can be abbreviated as ：

public class demo1 {
    
    public static void main(String[] args) {
    
        new Thread(() -> System.out.println("lambda The expression was executed ...")).start();
    }
}

labmda Benefits of expressions ：
1. You can simplify anonymous inner classes , Simplify the code

Two 、lambda The standard format of expressions

（ parameter list ）： parameter list
{}： Method body
-> : No special significance , Connect parameters and method bodies
1. No parameter no return value

public interface Swimingable {
    
    void swiming();
}

public class Swiming {
    
    public static void main(String[] args) {
    
        goSwiming(() ->{
    
            System.out.println(" I am a lambda swimming ");
        });

    }

    public static void goSwiming(Swimingable swimingable){
    
        swimingable.swiming();
    }

}

Run the following ：

 I am a lambda swimming 

Seeing that the parameter of the method is an interface, you can consider using lambda expression , But not all anonymous inner classes can be used ;ambda expression ,lambda Expressions are equivalent to rewriting interfaces .

1. With parameter and return value

public interface SmokeAble {
    
    int smoke(String name);
}

public class Smoking {
    
    public static void main(String[] args) {
    
        goSmoking((String name) -> {
    
            System.out.println("labmda I smoked today " + name + " The smoke of ");
            return 5;
        });
    }

    public static void goSmoking(SmokeAble s) {
    
        int i = s.smoke(" Yellow Crane Tower ");
        System.out.println(" Return value :" + i);
    }
}

The operation results are as follows ：

labmda Today, I smoked from the Yellow Crane Tower 
 Return value :5

Let's use lambda Implement sorting ：

public class PersonLambda {
    
    public static void main(String[] args) {
    
        List<Persion> persions = new ArrayList<>();
        persions.add(new Persion(" Lau Andy ", 55, 167));
        persions.add(new Persion(" Jacky Cheung ", 58, 174));
        persions.add(new Persion(" early summer ", 42, 180));

        Collections.sort(persions, (Persion o1, Persion o2) -> {
    
            return o1.getAge() - o2.getAge();
        });

        for (Persion persion:persions){
    
            System.out.println(persion);
        }
    }
}

Run the following ：

Persion{
    name=' early summer ', age=42, height=180}
Persion{
    name=' Lau Andy ', age=55, height=167}
Persion{
    name=' Jacky Cheung ', age=58, height=174}

3、 ... and 、lambda The ellipsis of 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 lower bracket , Parentheses can also be omitted ;
3. If there is only one statement in braces , You can omit braces at the same time ,return Statements and semicolons

Before omitting ：

(int a)->{
    
        return new Person();
        }

Omit ：

a -> new Person()

Four 、lambda Preconditions for the use of expressions

lambda Expression syntax is very brief , but lambda Expressions are not misused , There are several conditions that need special attention when using ：
1. The type of parameter or local variable of method must be interface type ;
2. There is only one abstract method in the interface ;

An interface with only one abstract method is called a functional interface , Just can use lambda expression ;

JDK8 I added a new one @FunctionalInterface annotation , It can help verify functional interfaces , If there are multiple abstract methods, an error will be reported .