方法引用与构造器引用

1.方法引用

1. 介绍:

   • 当要传递的lambda表达式 已经有实现方法了,就可以使用方法引用了,可以看作是lambda表达式的语法糖

   • 方法引用可以看作是Lambda表达式更深层次的表达,其实他们是一样的,只不过展现方式不同

2. 要求:

   • 实现接口的抽象方法的参数列表和返回值类型,必须与方法引用的方法参数列表和返回值类型保持一致

3. 格式:

   • 使用操作符 "::" 将类/对象与方法名分隔开来

4. 如:

   • 对象::实例方法名
   • 类::静态方法名
   • 类::实例方法名

2.使用情景

实现lambda表达式的实体方法的参数和返回值都和函数式接口的方法和返回值类型一样!!!!

这样就可以使用方法引用:例如consumer接口的方法是void accept(T t) 而System.out中的void println(T t)是一样的,所以可以使用方法引用 用System.out::print

1. 对象::非静态方法

   	@Test
       public void test1(){
           Employee employee=new Employee("tom",5000,24);
           Supplier supplier=()->employee.getName();
           System.out.println(supplier.get());
   
           System.out.println("**********************************");
   
           Supplier supplier2=employee::getAge;
           System.out.println(supplier2.get());
       }
   

2. 类::静态方法

       @Test
       public void test4(){
           Function<Double,Long> function0=new Function<Double, Long>() {
               @Override
               public Long apply(Double aDouble) {
                   return Math.round(aDouble);
               }
           };
           
           Function<Double,Long> function=d->Math.round(d);
   
           Function<Double,Long> function1=Math::round;
   
           Long apply = function.apply(5.0);
           Long apply1 = function1.apply(6.0);
   
       }
       @Test
       public void test5(){
           Consumer consumer=str-> System.out.println(str);
           consumer.accept("窗外的麻雀,在电线杆上多嘴");
   
           System.out.println("**********************************");
   
           PrintStream out = System.out;
           Consumer consumer1=out::println;
           consumer1.accept("你说这一句很有夏天的感觉");
   
           System.out.println("**********************************");
   
           Consumer consumer2= System.out::println;
           consumer2.accept("手中的铅笔在纸上来来回回");
   
       }
   

3. 类::非静态方法 ,第一个参数为方法调用者,可以理解为省略,param1 调 param2

       @Test
       public void test5() {
           Comparator<String> com0 = new Comparator<String>() {
               @Override
               public int compare(String o1, String o2) {
                   return o1.compareTo(o2);
               }
           };
   
           Comparator<String> com1 = (s1, s2) -> s1.compareTo(s2);
   
           Comparator<String> com2 = String::compareTo;
   
           //BiPredicate : boolean test(T t,T t1)
           //String equls: boolean equals(T t,T1)
           BiPredicate<String, String> biPredicate = new BiPredicate<String, String>() {
               @Override
               public boolean test(String s, String s2) {
                  return s.equals(s2);
               }
           } ;
   
           BiPredicate<String, String> biPredicate1 =  (s1, s2) -> s1.equals(s2);
           
           BiPredicate<String, String> biPredicate2 = String::equals;
   
       }
   
   	@Test
       public void test6() {
           //name,salary,age
           Employee employee=new Employee("tom",5000,24);
           Function<Employee,String> function=new Function<Employee, String>() {
               @Override
               public String apply(Employee employee) {
                   return employee.getName();
               }
           };
           Function<Employee,String> function2=e->e.getName();
   
           Function<Employee,String> function3=Employee::getName;
       }
   
   

2.构造器引用

是一种特殊的方法引用

	@Test
    public  void test7() {
        // supplier : T get()
        // Employee的无参构造器: 一个新对象 Employee();
        Supplier<Employee> supplier = new Supplier<Employee>() {
            @Override
            public Employee get() {
                return new Employee();
            }
        };
        Employee employee = supplier.get();

        Supplier<Employee> supplier2=()->new Employee();

        Supplier<Employee> supplier3=Employee::new;

    }


    @Test
    public  void test8() {
        //    Employee有一个有参构造器,age
        //    public Employee (Integer age){
        //        this.age=age;
        //    }
        Function<Integer,Employee> function = new Function<Integer, Employee>() {
            @Override
            public Employee apply(Integer integer) {
                return new Employee(integer);
            }
        };

        Employee apply = function.apply(24);

        Function<Integer,Employee> function2=age->new Employee(age);

        //此时,function3 调用的构造器为 public Employee (Integer age){}
        Function<Integer,Employee> function3=Employee::new;


    }

数组引用

    @Test
    public  void test9() {
        //数组引用
        Function<Integer,String[]> function=new Function<Integer, String[]>() {
            @Override
            public String[] apply(Integer integer) {
                return new String[integer];
            }
        };

        String[] apply = function.apply(5);
        System.out.println(Arrays.toString(apply));

        Function<Integer,String[]> function2= Length->new String[Length];
        //把数组看成特殊的类就可以了,数组其实就是类
        Function<Integer,String[]> function3=String[]::new;

    }