Lambda expression | shallow solution

Lambda expression

brief introduction

• Lambda Expressions support code blocks as method parameters , Allow more concise code to create an interface with only one abstract method （ It 's called a functional interface ） Example .
• Functional interface ： An interface that contains only one abstract method .
• Lambda The expression is equivalent to an anonymous method .
• effect ： Instead of the cumbersome syntax of anonymous inner classes .
• part ： Parameter list （ Parameter types are allowed to be omitted , parentheses ）; arrow -> ; Code block （ You can omit curly braces ,return）
• Lambda The expression will actually be treated as a Any type The object of .
• Lambda The essence of an expression is function .

( parameter list ) -> {
    
	 Method body ;
};

ordinary Lambda expression

• Implement... With anonymous inner classes ：

// Functional interface ： An interface that contains only one abstract method 
interface Cal{
    
     int add(int a, int b);
}

// This is our previous implementation , Anonymous inner class , Then the execution is called ;
public class Program {
    

    public static void main(String[] args) {
    
    	// Anonymous inner class 
        Cal c1 = new Cal() {
    
        	// Rewrite implementation interface 
            @Override
            public int add(int a, int b) {
    
                return a+b;
            }
        };
        
        // Calls to perform 
        int c = c1.add(1, 2);
        System.out.println(c);
    }
    
}

• use Lambda Expression rewriting ：

// Functional interface ： An interface that contains only one abstract method 
interface Cal{
    
     int add(int a, int b);
}

// use Lambda Expression rewriting ：
public class Program {
    

    public static void main(String[] args) {
    
    	//Lambda expression 
        Cal c1=(int a,int b) ->{
    
        	return a+b;
        };
        
        // Calls to perform 
        int c=c1.add(1,2);
        System.out.println(c);
    }
    
}

Lambda Expression syntax

• Make a case , Interface method parameters , No arguments , Single parameter , Two parameters , There is a return value , no return value , These six situations are listed below ：

public class Test {
    
    public static void main(String[] args) {
    
        
        I1 i1 = () -> {
    
            System.out.println(" No return value 、 No parameter ");
        };
        i1.test();// No return value 、 No parameter 
         
         
        I2 i2 = (int a, int b) -> {
    
            System.out.println(" No return value , Multiple parameters .a=" + a + ", b=" + b);
        };
        i2.test(2, 3);// No return value , Multiple parameters .a=2, b=3
        
        
        I3 i3 = () -> {
    
            System.out.println(" There is a return value 、 No parameter ");
            return 100;
        };
        System.out.println(i3.test());// There is a return value 、 No parameter  100
        
       
        I4 i4 = (int a, int b) -> {
    
            System.out.println(" There is a return value , Multiple parameters .a=" + a + ",b=" + b);
            return a + b;
        };
        System.out.println(i6.test(2, 4));// There is a return value , Multiple parameters .a=2,b=4 6
    }
}


interface I1 {
    
	// No return value 、 No parameter 
    void test();
}

interface I2 {
    
	// No return value , Multiple parameters 
    void test(int a, int b);
}

interface I3 {
    
	// There is a return value 、 No parameter 
    int test();
}

interface I4 {
    
	// There is a return value , Multiple parameters 
    int test(int a, int b);
}

Lambda Expression reduction Syntax

1. Parameter type It can be omitted .

2. If only One parameter ,() Brackets It can be omitted .

3. If the method body has only A sentence ,{} Curly braces It can be omitted .

4. If in the method body The only statement is return Return statement , When you omit the braces return You can omit it .

// Before omission 
I6 i6=(int a, int b)->{
    
 	return a+b;
 };

//  Omit ： Parameter type ,{} Curly braces ,return
I6 i6=(a,b)->a+b;

Method reference

• Sometimes more than one lambda If the expression implementation function is the same , We can encapsulate it as a generic method , To facilitate maintenance ;
• In this case, you can use method reference to implement ：
  Grammar is ： object :: Method （ Need to be new An object ）
  if static Method ： Class name :: Method （ There is no need to new An object , Direct class name ）

public class Program2 {
    

    public static void main(String[] args) {
    
        //  Method reference 
        
        //  Common method   Object name :: Method name  （ Need to be new An object ）
        Program2 program2 = new Program2();
        I5 i5 = program2::test;
        System.out.println(i5.test(1));

		// static Method   Class name :: Method name  （ There is no need to new An object , Direct class name ）
        I5 i52 = Program2::test2;
        System.out.println(i52.test(1));


    }

    public int test(int a){
    
        return a-2;
    }
	//static Method 
    public static int test2(int a){
    
        return a-2;
    }

}

interface I5{
    
    // A single parameter has a return value 
    int test(int a);
}

Construction method reference

• If the implementation of a functional interface can happen through Call the constructor of a class to implement , Then you can use the constructor to reference ;
• grammar ： Class name ::new

public class Program3 {
    

    public static void main(String[] args) {
    

        //  The ordinary way 
        DogService dogService = ()->{
    
            return new Dog();
        };
        dogService.getDog();

        //  Simplified method 
        DogService dogService2 = ()->new Dog();
        dogService2.getDog();

        //  Construction method reference 
        DogService dogService3 = Dog::new;
        dogService3.getDog();

        //  Construction method reference   Ginseng 
        DogService2 dogService21 = Dog::new;
        dogService21.getDog(" One, two, three ",8);
    }
}

// In defining two interfaces ：
interface DogService{
    
    Dog getDog();
}
interface DogService2{
    
    Dog getDog(String name,int age);
}


// So let's define one Dog Entity , Implementation of nonparametric and parametric construction methods 
class Dog {
    
    private String name;
    private int age;
    
    public Dog() {
    
        System.out.println(" Nonparametric construction method ");
    }
    public Dog(String name, int age) {
    
        System.out.println(" Parametric construction method ");
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
    
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

@FunctionalInterface annotation

• This annotation is a functional interface annotation , So called functional interfaces , Of course, the first is an interface , Then there is only one abstract method in this interface .
• Interface has and only has one abstract method
• The annotation It's not necessary , If an interface conforms to " Functional interface " Definition , So it doesn't matter whether the annotation is added or not . Add this annotation to make the compiler better able to check . If you're not writing a functional interface , But with it @FunctionInterface, Then the compiler will report an error

The system has built-in functional interfaces

• Java8 Launch , In order to Lambda Important features , Together with , A series of functional interfaces are built into the system .
• Again jdk Of java.util.function It's a bag , There's a series of built-in functional interfaces ： For example, common Consumer,Comparator,Predicate,Supplier etc. .

Lambda The relationship and difference between expressions and anonymous inner classes

• Lambda Expressions are a kind of anonymous inner classes simplify .
• The same thing ：（1） Can be accessed directly “effectively final” Local variables of , And the member variables of the external class ;（2） Can directly call the default method inherited from the interface .
• difference ：（1） Anonymous inner classes can be Any interface Create examples ,Lambda The expression can only be Functional interface Create examples ;（2） Anonymous inner classes can create instances for abstract classes and even different classes ;（3） Anonymous inner classes allow you to call the default methods defined in the interface .

Use Lambda Expression call Arrays Class method of

• Arrays Some methods of class need Comparator、XXXOperator、XXXFunction And other interfaces , It's all functional interfaces , So you can use Lambda Expression to call Arrays Class method of .

This paper is about Video Course Learning notes of , Add your own summary .