java8方法引用

Posted 2020-11-02 yuanbing1226

在java中我们可以通过创建新的对象来使用对象的引用

    List<String> list = new ArrayList<>();
    store(list);

那么对于方法呢，如果我们想在另一个方法中使用对象的方法，那么就必须将对象传递到这个方法中。试想以下，我们把方法的行为当参数传递会不会更好呢。在java8中，lambda表达式可以轻松做到这一点，方法引用的语法是 Object :: methodName。

    Consumer<String> c = s -> System.out.println(s);
    
    为了使代码更清晰，可以将lambda表达式转换为方法引用。
    
    Consumer<String> c = System.out :: println;

在方法引用中，将包含该方法的对象（或类）放在::运算符之前，并将该方法的名称放在没有参数的位置之后。首先，方法引用不能用于任何方法。它只能用于替换单个方法的lambda表达式。要使用lambda表达式，首先得有一个
函数接口，即一个只有一个抽象方法的函数接口。

几种类型的方法引用

• 1 对静态方法的方法引用。

• 2 对特定类型对象的示例方法的方法引用。
  
• 3 对现有对象实例方法的方法引用。
  
• 4 对构造函数的方法引用。

静态方法的方法引用

    （args）-> Class.staticMethod(args);
     Class :: staticMethod;
 

我们用方法引用符号 :: 代替 . ，并且不会将参数传递给方法引用，通常我们不必将参数传递给方法引用。但是参数取决于方法引用的类型。
在这种情况下，该方法采用的任何参数（如果有的话）会自动传递到后面。请看下例

    public static boolean isMoreThanFifty(int n1, int n2) {
        return (n1 + n2) > 50;
    }
    
    public static List<Integer> findNumbers(List<Integer> l, BiPredicate<Integer, Integer> p) {
        
        return l.stream()
                .filter(i -> p.test(i, i + 10))
                .collect(Collectors.toList());
    }

    /*
     * 使用匿名内部类实现
     */
    String s1 = findNumbers(list, new BiPredicate<Integer, Integer>() {

        @Override
        public boolean test(Integer t, Integer u) {
            
            return (t + u) > 50;
        }
    }).toString();
    System.out.println("s1 : " + s1);
    
    /**
     * 使用lambda表达式
     */
    String s2 = findNumbers(list, (i1, i2) -> Numbers.isMoreThanFifty(i1, i2)).toString();
    System.out.println("s2 : " + s2);
    /**
     * 使用方法引用
     */
    String s3 = findNumbers(list, Numbers :: isMoreThanFifty).toString();
    System.out.println("s3 : " + s3);

    //console log
    s1 : [45, 33, 24, 40]
    s2 : [45, 33, 24, 40]
    s3 : [45, 33, 24, 40]

对特定类型对象的示例方法的方法引用

我们有如下lambda表达式

    (obj, args) -> obj.instanceMethod(args)
    

如果一个对象的实例被传递，并且它的一个方法被执行了一些可选的参数，这可以转化为以下方法引用。

    ObjectType::instanceMethod
    
    public double calculateWeight() {
        double weight = 0;
        // Calculate weight
        return weight;
    }
    
    public void test() {
        List<Shipment> l = new ArrayList<Shipment>();

        // Using an anonymous class
        calculateOnShipments(l, new Function<Shipment, Double>() {
          public Double apply(Shipment s) { // The object
            return s.calculateWeight(); // The method
          }
        });

        // Using a lambda expression
        calculateOnShipments(l, s -> s.calculateWeight());

        // Using a method reference
        calculateOnShipments(l, Shipment::calculateWeight);
    }
    

对现有对象实例方法的方法引用

    public class Car {
        private String id;
        private String color;
    }
    
    public void execute(Car car, Consumer<Car> c) {
        c.accept(car);
    }
    
    execute(car, mechanic::fix);

对构造函数的方法引用

    Supplier<List<String>> supplier = new Supplier<List<String>>() {

        @Override
        public List<String> get() {
            return new ArrayList<String>();
        }
    };
    
    Supplier<List<String>> supplier2 = () -> new ArrayList<String>();
    
    Supplier<List<String>> supplier3 = ArrayList::new;
    
    /*
     * 如果构造函数有一个参数，可以使用Function接口。构造函数是两个参数的，可以使用BiFunction，如果是三个参数的话，则不得不创建以自己的函数接口了。
     */
    Function<String, Integer> function = Integer::new;
    
    BiFunction<String, String, Locale> biFunction = new BiFunction<String, String, Locale>() {

        @Override
        public Locale apply(String t, String u) {
            return new Locale(u, t);
        }
    };
    
    biFunction = (lang, country) -> new Locale(lang, country);
    
    biFunction = Locale::new;
    

结束语

在编程中使用方法引用，可以优化lambda，这样的代码更加简介，富于表达。上文中引用的代码可以在GitHub上进行下载

java8方法引用
为什么完美的lambda表达式只有一行
java8函数式编程