Java8新特性-Lambda表达式与方法引用

一、Lambda表达式

Lambda表达式的格式

举例：(o1,o2) -> Integer.compare(o1,o2);

• “->”：lambda操作符或箭头操作符
• “->左边”：lambda形参列表(其实就是接口中的抽象方法的参数列表)
• “->右边”：lambda体(其实就是重写接口的抽象方法的方法体)

Lambada表达式的本质就是接口(函数式接口)的实例

1.1 无参写法

Runnable rab1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello World");
    }
};
rab1.run();

/** 无参时"->"左边需要有一个空的括号() */
Runnable rab2 = () -> System.out.println("Hello World");
rab2.run();

1.2 一个参数写法

Consumer con1 = new Consumer() {
    @Override
    public void accept(Object o) {
        System.out.println(o);
    }
};
con1.accept("Hello World");

/** 一个参数时，可以忽略参数列表的括号() */
Consumer con2 = string -> System.out.println(string);
con2.accept("Hello World");

1.3 多个参数

Comparator<Integer> com1 = new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return Integer.compare(o1,o2);
    }
};
int compare1 = com1.compare(11,22);
System.out.println(compare1);

/** 多个参数时,参数需要用括号()包裹*/
Comparator<Integer> com2 = (o1,o2) -> Integer.compare(o1,o2);
int compare2 = com2.compare(11,22);
System.out.println(compare2);

1.4 方法体包含多条执行语句

Comparator<Integer> com1 = new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        System.out.println(o1);
        System.out.println(o2);
        return Integer.compare(o1,o2);
    }
};
int compare1 = com1.compare(11,22);
System.out.println(compare1);

/** 当方法体包含多条语句时,需要用{}包裹 */
Comparator<Integer> com2 = (o1,o2) -> {
    System.out.println(o1);
    System.out.println(o2);
    return Integer.compare(o1,o2);
};
int compare2 = com2.compare(11,22);
System.out.println(compare2);

如果Lambda体只有一条执行语句,则不需要"{}"和return,如果有多条执行语句时,"{}"和return必须都要有

二、函数接口

2.1 函数接口定义

只包含一个自定义抽象方法的接口称为函数式接口，不论有没有@FunctionalInterface注解，它都是一个函数式接口，使用注解可以检查它是否是一个函数式接口，同时javadoc也会包含一个声明，说明这个接口是一个函数式接口

@FunctionalInterface注解的接口中，必须满足只有一个非static和default的函数才能称之为函数接口，不然注解会报错，但接口中可以存在Object类的方法

@FunctionalInterface
public interface Test {
    void test(String str);

    @Override
    boolean equals(Object object);

    @Override
    String toString();

    static void print(){
        System.out.println("");
    }

    default void show(){
        System.out.println("");
    }
}

上面的代码展示了一个函数式接口,可以重写Object类的public方法,可以有static和default方法,但只能有一个自定义的抽象方法

2.2 函数式接口的使用

• 定义一个函数式接口，有且仅有一个自定义抽象方法，但可以有Object类的public方法，protected方法不行

  

• 方法中调用函数接口的方法

  

• 外部方法调用该类的方法时，可以自定义实现函数接口的函数，格式(函数接口方法参数)->{具体实现}

  

2.3 内置四大函数式接口

• Consumer： 消费型接口

  void accept(T t);
  

• Supplier：供给型接口

  T get();
  

• Function<T,R>：函数型接口

  R apply(T t);
  

• Predicate：断言型接口

  boolean test(T t);
  

  断言型接口的使用，过滤集合元素

  public void test(){
      List<String> list = Arrays.asList("lizhi","linan","zhuyuzhu");
      List<String> filterList = filterString(list,name -> name.contains("zh"));
      System.out.println(filterList);
  }
  
  /** 将满足条件的元素装入新的列表返回 */
  private List<String> filterString(List<String> list, Predicate<String> predicate){
      List<String> filterList = new ArrayList<>();
      for (String name: list) {
          if (predicate.test(name)){
              filterList.add(name);
          }
      }
  
      return filterList;
  
  }
  

在大多数场景中,内置的四种函数式接口都可以满足开发需求,在java.util.function包下面还包含了很多基于这四种函数式接口拓展的其他函数式接口

上面函数式接口使用的例子可以直接用消费型接口实现

Demo demo = new Demo();
demo.method("Hello World",(str)-> {
    System.out.println("this is functional interface");
    System.out.println(str);
});

public void method(String str, Consumer test){
    System.out.println("This is main method");
    test.accept(str);
}

Lambda表达式是基于函数式接口实现的

三、方法引用与构造引用

当要传递给Lambda体的操作，已经有实现的方法，则可以使用方法引用。意思就是说原来Lambda体的操作是执行某个类或对象的方法，这时Lambda体就可以采用方法引用来实现，方法引用其实就是Lambda表达式的语法糖，是一种更高层次的表达而已

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

/** 格式 */
类名/对象 :: 方法;  //通过“::”将类或对象与方法名分开,表达Lambda方法体执行的是该方法
//主要有三种使用情况
对象 :: 实例方法名
  类 :: 静态方法名
  类 :: 实例方法名  //这种情况上面的要求不再符合

调用静态方法只能通过类,不能通过对象来调

3.1 方法引用

3.1.1 无返回值且参数列表一致

/**
 *	Consumer的方法：void accepte(T t)
 *	System.out表示的是PrintStream
 * 	PrintStream的方法：void println(T t)
 */
//lambda表达式
Consumer con1 = s -> System.out.println(s);
con1.accept("Hello World");
//方法引用
Consumer con2 = System.out :: println;
con2.accept("Hello World");

3.1.2 返回值类型一致且无参数列表

/**
 *	Supplier的方法：T get()
 *	User的方法：String getName()
 */
//lambda表达式
User user = new User(1,"lizhi","man","159");
Supplier sup1 = () -> user.getName();
System.out.println(sup1.get());

//方法引用
Supplier sup2 = user :: getName;
System.out.println(sup2.get());

3.1.3 有参数列表且返回值类型一致

//方法引用的方法的参数列表和compare抽象方法的参数列表一致
Comparator<Integer> com1 = (o1,o2) -> Integer.compare(o1,o2);
int result1 =  com1.compare(11,22);

Comparator<Integer> com2 = Integer :: compare;
int result2 = com2.compare(11,22);

//apply方法和round的方法对应的返回值和参数列表类型一致
Function<Double,Long> function1 = d -> Math.round(d);
long result1 = function1.apply(0.5);

Function<Double,Long> function2 = Math :: round;
long result2 = function2.apply(0.5);

3.1.4 类调实例方法

/**
 *	Comparator的方法：int compare(T t1,T t2)
 *	String的方法：int compareTo(T t)  由实例发起调用
 */
Comparator<String> com1 = (c1,c2) -> c1.compareTo(c2);
int result1 = com1.compare("dag","aia");

Comparator<String> com2 = String :: compareTo;
int result2 = com2.compare("dag","aia");

这个写法理解起来比较难，Comparator的抽象方法compare包含两个String类型的参数，而调用String的compareTo方法只有一个参数，compare中的第一次参数主要的作用就是调用的发起者，同时第一个参数也是String的实例，所以通过类调用实例方法，其实是因为Comparator抽象方法的第一次参数是该类的实例

/**
 *	BiPredicate的方法：boolean test(T t1,U t2)
 *	String的方法：boolean equals(T t)  由实例发起调用
 */
BiPredicate<String,String> bi1 = (b1,b2) -> b1.equals(b2);
bi1.test("lizhi","linan");

BiPredicate<String,String> bi2 = String :: equals;
bi2.test("lizhi","linan");

下面的例子中，apply抽象方法有一个参数，getName方法没有参数，但getName方法需要有一个发起调用的实例，所以apply方法的参数就是充当User实例的角色

/**
 *	Function的方法：R apply(T t)
 *	User的方法：String getName()  由实例发起调用
 */
User user = new User(1,"lizhi","man","159");

Function<User,String> fun1 = u -> u.getName();
String userName1 =  fun1.apply(user);

Function<User,String> fun2 = User :: getName;
String userName2 = fun2.apply(user);

3.2 构造引用

3.2.1 无参构造

Supplier<User> sup1 = () -> new User();
User user1 = sup1.get();

Supplier<User> sup2 = User::new;
User user2 = sup2.get();

3.2.2 单参数构造

//User有一个参数为int类型的构造器，无需指明参数类型
Function<Integer,User> fun1 = id -> new User(id);
User user1 = fun1.apply(100);

Function<Integer,User> fun2 = User :: new;
User user2 = fun2.apply(200);

3.2.3 多参构造器

BiFunction<Integer,String,User> bif1 = (id,name) -> new User(id,name);
User user1 = bif1.apply(100,"lizhi");

BiFunction<Integer,String,User> bif2 = User :: new;
User user2 = bif2.apply(200,"linan");

3.3数组引用

Function<Integer,String[]> fun1 = length -> new String[length];
String[] array1 = fun1.apply(5);

Function<Integer,String[]> fun2 = String[] :: new;
String[] array2 = fun2.apply(5);