接上一篇，lambda表达式的基本逻辑，这次总结了接种特殊的使用方法。
一、对象::实列方法名
特点：
1、表达式体调用的方法，在接口中已经实现，不需要再在调用的时候实现。使用此方法；
2、调用的方法，参数列表和返回值，既已经实现的方法签名，和Lambda表达式一致；
@Test
public void test1(){
Consumer<String> consumer1 = (x)-> System.out.println(x);
//上面表达式的简写如下
Consumer<String> consumer2 = System.out::println;
consumer1.accept("This is output sequence");//控制它输出：This is output sequence
}
Consumer是Java自带的接口，是“消费性”接口，以上代码的大白话可以翻译成：接口的accept方法接受一个参数，它的据体实现是打印接收到的那句话。此时可以将参数省略。该接口部分代码如下：
@FunctionalInterface
public interface Consumer<T> {
/**
* Performs this operation on the given argument.
*
* @param t the input argument
*/
void accept(T t);
}
二、类::静态方法名
@Test
public void test3(){
Comparator<Integer> com = (x,y)->Integer.compare(x,y);
System.out.println(com.compare(20,22));//输出：-1
Comparator<Integer> compare = Integer::compare;
System.out.println(compare.compare(20,22));//输出：-1
}
Comparator接口的“比较”部分代码如下：
@FunctionalInterface
public interface Comparator<T> {
/**
* 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<Integer> {
public static int compare(int x, int y) {
return (x < y) ? -1 : ((x == y) ? 0 : 1);
}
}
三、类::实列方法
@Test
public void test4(){
BiPredicate<String,String> bp = (x ,y )->x.equals(y);
//此方法使用限制：
//x是方法的调用者，y是方法参数
BiPredicate<String, String> bp2= String::equals;
System.out.println(bp2.test("a","ab")); //output: false
}
BiPredicate接口部分代码如下：
@FunctionalInterface
public interface BiPredicate<T, U> {
/**
* 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<Employee> emp = ()->new Employee(); //实例化返回一个employee对象
Supplier<Employee> emp1= Employee::new;
//调用，根据无参构造，返回一个对象
Employee employee = emp.get();
//调用一个参数的构造函数
Function<Integer, Employee> fun1 = (number)->new Employee(number);
Function<Integer, Employee> fun2 = Employee::new ;
//调用，根据用户编号返回用户
Employee employeer = fun1.apply(201);
}
Java自带Supplier接口，代码如下：
@FunctionalInterface
public interface Supplier<T> {
/**
* Gets a result.
*
* @return a result
*/
T get();
}
Function接口的部分代码如下：
@FunctionalInterface
public interface Function<T, R> {
/**
* 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<Integer, String[]> fun = (x)->new String[x];
String[] strings = fun.apply(10);
System.out.println(strings.length);//输出10
Function<Integer, String[]> fun2= String[]::new;
String[] strings1 = fun2.apply(20);
System.out.println(strings1.length);//输出20
}
数组也是一个对象。
以上五种写法，归根结底，还是不变的先定义接口，然后定义一个方法，将接口作为形参，最后使用lambda表达式作为实参传入方法，实现接口中的方法的具体实现。
