java8新特性之eta-conversion

        在JDK8新特性中出现方法引用，而双冒号运算操作符是类方法的句柄，lambda表达式的一种简写，这种简写的学名又叫 eta-conversion 或者 η-conversion。

1.为什么要用方法引用？

在lambda表达式的时候，也会出现代码冗余的情况，比如：用lambda表达式求一个数组的和

import java.util.function.Consumer;

/**
 * @author ftygc
 */
public class FunctionRefTest {
    public static void main(String[] args){
        privateMax(a->{
            int sum=0;
            for(int i:a){
                sum+=i;
            }
            System.out.println("数组之和："+sum);
        });
    }

    public void getTotal(int a[]){
        int sum=0;
        for(int i:a){
            sum+=i;
        }
        System.out.println("数组之和："+sum);
    }
    private static void privateMax(Consumer<int[]> consumer) {
        int[] a={10,20,30,40,50,60};
        consumer.accept(a);
    }
}

解决：因为在Lambda表达式中要执行的代码和我们另一个方法中的代码是一样的，这时就没有必要重写一份逻辑了，这时我们就可以“引用”重复代码

import java.util.function.Consumer;

/**
 * @author ftygc
 */
public class FunctionRefTest01 {
    public static void main(String[] args){
        //::方法引用  也是JDK8中的新的语法
        privateMax(FunctionRefTest01::getTotal);
    }

    public static void getTotal(int a[]){
        int sum=0;
        for(int i:a){
            sum+=i;
        }
        System.out.println("数组之和："+sum);
    }
    private static void privateMax(Consumer<int[]> consumer) {
        int[] a={10,20,30,40,50,60};
        consumer.accept(a);

    }
}

：：方法引用也是JDK8中的新的语法

2.方法引用的格式

符号表示：::

符号说明：双冒号为方法引用运算符，而它所在的表达式被称为方法引用

应用场景：如果Lambda表达式所要实现的方案，已经有其他方法存在相同的方案，那么则可以使用方法引用。

常见的引用方式：

方法引用在JDK8中使用是相当灵活的，有以下几种形式：

1. instanceName::methodName 对象::方法名

2. ClassName::staticMethodName 类名::静态方法

3. ClassName::methodName 类名::普通方法

4. ClassName::new 类名::new 调用的构造器

5. TypeName[]::new String[]::new 调用数组的构造器

1.对象::方法名

这是最常见的一种用法，如果一个类中已经存在了一个成员方法，则可以通过对象名引用成员方法

public static void main(String[] args){
    Date now=new Date();
    Supplier<Long> supplier=()->{
        return now.getTime();
    };
    System.out.println(supplier.get());
    //然后我们通过方法引用的方式来处理
    Supplier<Long> supplier1=now::getTime;
    System.out.println(supplier1.get());

}

方法引用的注意事项：

1.被引用的方法，参数要和接口中的抽象方法的参数一样

2.当接口抽象方法有返回值时，被引用的方法也必须有返回值

2.类名::静态方法名

也是比较常用的方式

public static void main(String[] args){
    Supplier<Long> supplier1=()->{
        return System.currentTimeMillis();
    };
    System.out.println(supplier1.get());
    //通过方法引用来实现
    Supplier<Long> supplier2=System::currentTimeMillis;
    System.out.println(supplier2.get());
}

1. 3.类名::引用实例方法

Java面向对象中，类名只能调用静态方法，类名引用实例方法是有提前的，实际上是拿第一个参数作为方法的调用者

public static void main(String[] args){
    Function<String,Integer> function=(s)->{
        return s.length();
    };
    System.out.println(function.apply("hello"));
    //通过方法引用来实现
    Function<String,Integer> function1=String::length;
    System.out.println(function1.apply("world"));

    BiFunction<String,Integer,String> function2=String::substring;
    String msg=function2.apply("HELLOWORLD",3);
    System.out.println(msg);
}

1. 4.类名::构造器

由于构造器的名称和类名完全一致，所以构造器引用使用::new的格式使用

public static void main(String[] args){
    Supplier<Person> sup=()->{return new Person();};
    System.out.println(sup.get());
    //然后通过 方法引用来实现
    Supplier<Person> sup1=Person::new;
    System.out.println(sup1.get());
    BiFunction<String,Integer,Person> function=Person::new;
    System.out.println(function.apply("wangyu",22));
}

--------------------------------------

//person类
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person {
    private String name;
    private Integer age;
}

1. 5.数组::构造器

     数组是怎么构造出来的呢？

public static void main(String[] args){
    Function<Integer,String[]> fun1=(len)->{
        return new String[len];
    };
    String[] a1=fun1.apply(3);
    System.out.println("数组的长度是："+a1.length);
    //方法引用的方式来调用数组的构造器
    Function<Integer,String[]> fun2=String[]::new;
    String[] a2=fun2.apply(5);
    System.out.println("数组的长度是："+a2.length);
}

3.小结

方法引用是对Lambda表达式符合特定情况下的一种缩写方式，它使得我们的Lambda表达式更加的精简，也可以理解为lambda表达式的缩写形式，不过要注意的是方法引用只能引用已经存在的方法