Java 8 Lambda表达式常见写法

接上一篇，lambda表达式的基本逻辑，这次总结了接种特殊的使用方法。

一、对象::实列方法名

特点：
1、表达式体调用的方法，在接口中已经实现，不需要再在调用的时候实现。使用此方法；
2、调用的方法，参数列表和返回值，既已经实现的方法签名，和Lambda表达式一致；

@Test
    public void test1(){
        Consumer consumer1 = (x)-> System.out.println(x);
        //上面表达式的简写如下
        Consumer consumer2 = System.out::println;
        consumer1.accept("This is output sequence");//控制它输出：This is output sequence
    }

Consumer是Java自带的接口，是“消费性”接口，以上代码的大白话可以翻译成：接口的accept方法接受一个参数，它的据体实现是打印接收到的那句话。此时可以将参数省略。该接口部分代码如下：

@FunctionalInterface
public interface Consumer {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);
}

二、类::静态方法名

@Test
public void test3(){
    Comparator com = (x,y)->Integer.compare(x,y);
    System.out.println(com.compare(20,22));//输出：-1
    
    Comparator compare = Integer::compare;
    System.out.println(compare.compare(20,22));//输出：-1
}

Comparator接口的“比较”部分代码如下：

@FunctionalInterface
    public interface Comparator {
        /**
         * Compares its two arguments for order.  Returns a negative integer,
         * zero, or a positive integer as the first argument is less than, equal
         * to, or greater than the second.

         * @param o1 the first object to be compared.
         * @param o2 the second object to be compared.
         * @return a negative integer, zero, or a positive integer as the
         *         first argument is less than, equal to, or greater than the
         *         second.
         * @throws NullPointerException if an argument is null and this
         *         comparator does not permit null arguments
         * @throws ClassCastException if the arguments' types prevent them from
         *         being compared by this comparator.
         */
        int compare(T o1, T o2);
    }

Integer的compare方法定义如下：

public final class Integer extends Number implements Comparable {
    public static int compare(int x, int y) {
        return (x < y) ? -1 : ((x == y) ? 0 : 1);
    }
}

三、类::实列方法

@Test
public void test4(){
    BiPredicate bp = (x ,y )->x.equals(y);
    //此方法使用限制：
    //x是方法的调用者，y是方法参数
    BiPredicate bp2= String::equals;
    System.out.println(bp2.test("a","ab")); //output: false
}

BiPredicate接口部分代码如下：

@FunctionalInterface
public interface BiPredicate {
/**
* Evaluates this predicate on the given arguments.
*
* @param t the first input argument
* @param u the second input argument
* @return {@code true} if the input arguments match the predicate,
* otherwise {@code false}
*/
boolean test(T t, U u);
}

String.equals()的签名如下：

public boolean equals(Object anObject) {}

四、构造器引用

格式： classname::new
被调用的构造器的参数列表，与接口中抽象方法的参数列表一致。

@Test
public void test5(){
    //调用哪种构造参数，取决于接口，
    //==>> 如Supplier的方法，是无参函数
    //==>> Function的方法，接受一个参数，返回一个类型
    //调用无参构造
    Supplier emp = ()->new Employee(); //实例化返回一个employee对象
    Supplier emp1= Employee::new;
    //调用，根据无参构造，返回一个对象
    Employee employee = emp.get();

    //调用一个参数的构造函数
    Function fun1 = (number)->new Employee(number);
    Function fun2 = Employee::new ;
    //调用，根据用户编号返回用户
    Employee employeer = fun1.apply(201);
}

Java自带Supplier接口，代码如下：

@FunctionalInterface
public interface Supplier {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

Function接口的部分代码如下：

@FunctionalInterface
public interface Function {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);
}

五、数组引用

 @Test
 public void test6(){
     Function fun = (x)->new String[x];
     String[] strings = fun.apply(10);
     System.out.println(strings.length);//输出10

    Function fun2= String[]::new;
    String[] strings1 = fun2.apply(20);
    System.out.println(strings1.length);//输出20
}

数组也是一个对象。

以上五种写法，归根结底，还是不变的先定义接口，然后定义一个方法，将接口作为形参，最后使用lambda表达式作为实参传入方法，实现接口中的方法的具体实现。