JAVA8新特性-Lambda表达式

一、Lambda表达式的基础语法

Java8中引入了一个新的操作符 “->”，称为箭头操作符或者Lambda操作符。
Lambda操作符将Lambda表达式拆分成了2部分：

• 左侧：Lambda表达式的参数列表
• 右侧：Lambda表达式中所需要执行的功能，即Lambda体
  语法格式：
• 1、无参数，无返回值

  () -> System.out.println("hello,lambda");
  
  Runnable r = ()-> System.out.println("hello, lambda");
  r.run();
  

• 2、有一个参数，无返回值

  (x) -> System.out.println(x);
  
  Consumer<String> con = (x) -> System.out.println(x);
  con.accept("hello, lambda")
  

• 3、若只有一个参数，那么表达式左边的（）可以省略不写

  x -> System.out.println(x);
  
  Consumer<String> con = x -> System.out.println(x);
  con.accept("hello, lambda")
  

• 4、有两个以上的参数，有返回值，并且函数体中有多条表达式：

  Comparator<Integer> comp = (x,y) -> {
  	System.out.println("hello, lambda");
  	return Integer.compare(x, y);
  }
  

• 5、有两个以上的参数，有返回值，并且函数体中只有一条表达式，表达式外部的{} 可以省略不写

  Comparator<Integer> comp = (x,y) -> return Integer.compare(x, y);
  

• 6、Lambda表达式参数列表的数据类型，可以省略不写，因为编译器可以通过上下文推断，即“类型推断”

  Comparator<Integer> comp = (Integer x, Integer y) -> return Integer.compare(x, y);
  
  Comparator<Integer> comp = (x,y) -> return Integer.compare(x, y);
  

函数式接口

Lambda表达式需要函数式接口的支持。
函数式接口：接口中只有一个抽象方法的接口，称为函数式接口。
函数式接口，可以使用@FunctionalInterface来进行修饰，可以达到检查该接口是否为函数式接口的作用。
Java8中提供了四大内置核心函数式接口：

• 1、消费型接口Consumer

  @FunctionalInterface
  public interface Consumer<T> {
      void accept(T t);
      default Consumer<T> andThen(Consumer<? super T> after) {
          Objects.requireNonNull(after);
          return (T t) -> { accept(t); after.accept(t); };
      }
  }
  

• 2、供给型接口Supplier

  @FunctionalInterface
  public interface Supplier<T> {
      T get();
  }
  

• 3、函数型接口Function

  @FunctionalInterface
  public interface Function<T, R> {
      R apply(T t);
      default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
          Objects.requireNonNull(before);
          return (V v) -> apply(before.apply(v));
      }
      default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
          Objects.requireNonNull(after);
          return (T t) -> after.apply(apply(t));
      }
      static <T> Function<T, T> identity() {
          return t -> t;
      }
  }
  

• 4、断言型接口Predicate

  @FunctionalInterface
  public interface Predicate<T> {
      boolean test(T t);
      default Predicate<T> and(Predicate<? super T> other) {
          Objects.requireNonNull(other);
          return (t) -> test(t) && other.test(t);
      }
      default Predicate<T> negate() {
          return (t) -> !test(t);
      }
      default Predicate<T> or(Predicate<? super T> other) {
          Objects.requireNonNull(other);
          return (t) -> test(t) || other.test(t);
      }
      static <T> Predicate<T> isEqual(Object targetRef) {
          return (null == targetRef)
                  ? Objects::isNull
                  : object -> targetRef.equals(object);
      }
  }
  

方法引用

若Lambda体中的内容已经有方法实现了，那我们可以使用“方法引用”，可以理解为lambda表达式的另外一种表现形式。
当lambda表达式中只有一条语句，并且此语句中调用的方法和lambda表达式中实现的函数式接口具有相同的参数和返回值时，可以采用方法引用的方式来进行简化。
方法引用主要有三种语法格式：

• 格式一：对象：：实例方法名

  @Test
  public void test_lambda1(){
      //方式一：匿名内部类
      Consumer<String> con1 = new Consumer<String>() {
          @Override
          public void accept(String s) {
              System.out.println(s);
          }
      };
      con1.accept("hello, lambda");
  
      //方式二：lambda表达式
      Consumer<String> con2 = (s) -> System.out.println(s);
      con2.accept("hello, lambda");
  
      //方式三：方法引用
      Consumer<String> con3 = System.out::println;
      con3.accept("hello, lambda");
  
  	User user = new User(1, "huwenchao", 35, "huwenchao@126.com");
      Supplier<String> sup1 = new Supplier<String>() {
          @Override
          public String get() {
              return user.getName();
          }
      };
      System.out.println(sup1.get());
  
      Supplier<String> sup2 = () -> {return user.getName();};
      System.out.println(sup2.get());
  
      Supplier<String> sup3 = () -> user.getName();
      System.out.println(sup3.get());
      
      Supplier<String> sup4 = user::getName;
      System.out.println(sup4.get());
  }
  
  

• 格式二：类：：静态方法名

  @Test
  public void test_lambda2(){
      //匿名内部类方式
      Comparator<Integer> com1 = new Comparator<Integer>() {
          @Override
          public int compare(Integer o1, Integer o2) {
              return Integer.compare(o1, o2);
          }
      };
      System.out.println(com1.compare(1, 2));
      
      //lambda表达式方式
      Comparator<Integer> com2 = (o1, o2) -> {return Integer.compare(o1, o2);};
      System.out.println(com2.compare(1, 2));
  
      //方法引用方式
      Comparator<Integer> com3 = Integer::compare;
      System.out.println(com3.compare(1, 2));
  }
  

• 格式三：类：：实例方法名
  lambda表达式中有2个参数，第一个参数是lambda体中实例方法的调用者，而第二个参数是实例方法的参数时，可以使用类：：实例方法名方式的方法引用。

  @Test
  public void test_lambda3(){
      //匿名内部类
      BiPredicate<String, String> bip1 = new BiPredicate<String, String>() {
          @Override
          public boolean test(String s, String s2) {
              return s.equals(s2);
          }
      };
      System.out.println(bip1.test("huwenchao", "huwenchao2"));
      
      //lambda表达式
      BiPredicate<String, String> bip2 = (x, y) -> {return x.equals(y);};
      System.out.println(bip2.test("huwenchao", "huwenchao2"));
      
      //方法引用
      BiPredicate<String, String> bip3 = String::equals;
      System.out.println(bip3.test("huwenchao", "huwenchao2"));
  }
  

构造器引用

格式：ClassName：：new
同理，此时调用的无参构造器还是有参构造器，取决于lambda表达式中的参数列表

@Test
public void test_lambda4(){
    //匿名内部类
    Supplier<User> sup1 = new Supplier<User>() {
        @Override
        public User get() {
            return new User();
        }
    };
    System.out.println(sup1.get());
    
    //lambda表达式
    Supplier<User> sup2 = () -> new User();
    System.out.println(sup2.get());
    
    //构造器引用
    Supplier<User> sup3 = User::new;
    System.out.println(sup3.get());

	//有参构造器，匿名内部类
    Function<String, User> fun1 = new Function<String, User>() {
        @Override
        public User apply(String s) {
            return new User(s);
        }
    };
    System.out.println(fun1.apply("huwenchao"));

    //有参构造器，lambda表达式
    Function<String, User> fun2 = (name) -> new User(name);
    System.out.println(fun2.apply("huwenchao"));

    //有参构造器，构造器引用
    Function<String, User> fun3 = User::new;
    System.out.println(fun3.apply("huwenchao"));
}

数组引用

格式：Type：：new

@Test
public void test_lambda5(){
  //匿名内部类
  Function<Integer, String[]> fun1 = new Function<Integer, String[]>() {
      @Override
      public String[] apply(Integer integer) {
          return new String[integer];
      }
  };
  System.out.println(fun1.apply(10).length);
  
  //lambda表达式
  Function<Integer, String[]> fun2 = (count) -> new String[count];
  System.out.println(fun2.apply(10).length);
  
  //数组引用
  Function<Integer, String[]> fun3 = String[]::new;
  System.out.println(fun3.apply(10).length);
}