lambda表达式方法引用

lambda表达式 以及方法引用

lambda表达式
本质是一个函数：
一般的函数类如下：
有返回值，方法名，参数列表，方法体

 int  add(int  a , int  b ){
 return  a+b
 }

lambda表达式的话，只有参数列表，方法体
（参数 列表）->{方法体}
（）用来描述参数列表
{ } 用来描述方法体
-> 是lambda运算符，箭头运算符

 lambda表达式
 			cal c = (int a, int b) -> {
           			 return a + b;
            			};
            
 精简代码：
		   cal c = (a,b) -> a + b;

Lambda表达式精简语法
1、参数类型可以省略
2、假如只有一个参数，（）可以省略
3、如果方法体只有一个语句{ }可以省略
4、如果方法体唯一的语句是return返回语句，那么{ }和return要同时省略
lambda表达式，实现接口方法

 */
public class Por {
    public static void main(String[] args) {
       
方法重写实现接口方法1

       cal cc=new cal() {
            @Override
            public int add(int a, int b) {
                return a+b;
            }
        };
        System.out.println(cc.add(1,2));
--------------------------------------------------------------------

lambda表达式，实现接口的方法2
      
        cal c = (int a, int b) -> {
            return a + b;
        };
        System.out.println(c.add(2,9));
    }
    public interface cal {
        int add(int a, int b);
    }
}

lambda表达式静态引用

1、lambda表达式方法引用 如果lambda表达式方法体已经有其他方法/现那么则可以使用方法引用
2、静态方法引用 类名：：方法名
3、实例方法引用 实例名：：方法名
构造方法引用：
4、无参构造方法引用 类名：：new
5、有参构造方法引用 实例名 ：：new

public class Penson {
     private String name;
     private int age;
     
//无参构造方法
     public Penson(){

     }
     
//有参构造方法
     public Penson (String name,int age){
         this.name=name;
         this.age=age;
     }
     
//get和set
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

//静态方法求和方法
    public static int staticsum(int a ,int b){
         return a + b;
    }
    
//非静态求和方法（实例化方法引用）
    public int sum(int a,int b){
         return a + b;
    }
}

1、lambda表达式静态方法引用

public class PensonTest {
@Test
    public void test() {
    int i=Penson.staticsum(10,20);
    //用Penson::staticsum
    //Function  函数式接口（一个输入一个输出）
    //BiFunction  函数式接口（一个输入二个输出）这里有二个输入一个返回用
    BiFunction<Integer,Integer,Integer>biFunction1= Penson::staticsum;
    Integer sum = biFunction1.apply(10,20);
    System.out.println(sum);
}
}

2.lambda表达式 非静态、实例方法引用

@Test
    public void test01() {
    //非静态方法引用，实例方法引用
        Penson penson=new Penson();
        BiFunction<Integer,Integer,Integer>biFunction = penson::sum;
        Integer sum=biFunction.apply(30,20);
        System.out.println(sum);
    }
}

3、toString lambda无参构造方法引用

    }
//toString lambda无参构造方法引用
    @Test
    public void test02() {
        Supplier<Penson>supplier = Penson::new;
        Penson penson=supplier.get();
        penson.setAge(19);
        penson.setName("名字") ;
        System.out.println(penson);
    }
}

4、lambda有参构造方法引用

 有参构造方法引用
 @Test
    public void test03() {
        //完整写法
       // BiFunction<String,Integer,Penson>biFunction = (name,age)-> new Penson(name,age);
        BiFunction<String,Integer,Penson>biFunction = Penson::new;
        Penson penson= biFunction.apply("名字",22);
        System.out.println(penson);
    }
    
}

lambda表达式特殊实例方法引用

lambda表达式数组方法引用

 @Test
    public void test04() {
        // String[] name=new String[10];
        Function<Integer, String[]> function = (count) -> new String[count];
        String[] name = function.apply(10);
        System.out.println(name.length);
    }

    @Test
    public void test05() {
        // String[] name=new String[10];
        Function<Integer, String[]> function = String[]::new;
        String[] name = function.apply(10);
        System.out.println(name.length);
    }
}