java8新特性——Lambda表达式

概述

Java8最值得学习的特性就是Lambda表达式和Stream API，java的lambda表达式相当于python中的lambda表达式或者ES6中的箭头函数。
Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。使用 Lambda 表达式可以使代码变的更加简洁紧凑，更利于阅读。
Lambda表达式可以使java拥有函数式编程

Lambda表达式语法

Lambda表达式的语法一般如下：

(parameters) -> expression
或
(parameters) ->{ statements; }

Lambda引入了->操作符，该操作符将函数分成两部分

• 左侧： 指定了 Lambda 表达式需要的所有参数
• 右侧： 指定了 Lambda 体，即 Lambda 表达式要执行的功能

Lambda主要有以下特点

• 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
• 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
• 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
• 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

下面通过测试代码进行测试

测试

1. 语法格式一：无参，无返回值，Lambda 体只需一条语句
   () -> System.out.println("helloworld")

public void test1() {
   Runnable r = () -> System.out.println("hello world");
    r.run();
}

2. 语法格式二：Lambda 需要一个参数，Lambda只有一个参数时
   (x) -> System.out.println(x)
   只有一个参数时，小括号可以省略
   x -> System.out.println(x)

@Test
public void test2() {
    Consumer<String> con = (s) -> System.out.println(s);
    Consumer<String> con1 = s -> System.out.println(s);
}

3. 语法格式四：有两个以上的参数，有返回值，并且 Lambda 体中有多条语句

Comparator<Integer> com = (x , y) -> {
   System.out.println(x - y);
    return Integer.compare(x, y);
};
TreeSet<Integer> treeSet = new TreeSet<>((x, y) -> {
    System.out.println(x +  y);
    return Integer.compare(x, y);
});

4. 若 Lambda 体中只有一条语句， return 和 大括号都可以省略不写

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

Lambda中的类型推断

上述 Lambda 表达式中的参数类型都是由编译器推断得出的。 Lambda 表达式中无需指定类型，程序依然可以编译，这是因为 javac 根据程序的上下文，在后台推断出了参数的类型。 Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的“类型推断”

函数式接口

什么是函数式接口

• 只包含一个抽象方法的接口，称为函数式接口。
• 你可以通过 Lambda 表达式来创建该接口的对象。（若 Lambda表达式抛出一个受检异常，那么该异常需要在目标接口的抽象方法上进行声明）。
• 我们可以在任意函数式接口上使用 @FunctionalInterface注解，这样做可以检查它是否是一个函数式接口，同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。

自定义函数式接口并使用

// 定义
public interface MyFunInteface<T> {
    T get(T t);
}


// 使用

@Test
public void test3() {
     MyFunInteface<String> f = s -> s.toLowerCase();

     System.out.println(changeString("I Love China",f));
     System.out.println(changeString("i love china",s -> s.toUpperCase()));
 }

 public String changeString(String s, MyFunInteface<String> f) {
     return f.get(s);
 }

作为参数传递 Lambda 表达式：为了将 Lambda 表达式作为参数传递，接收Lambda 表达式的参数类型必须是与该 Lambda 表达式兼容的函数式接口的类型

Java 内置四大核心函数式接口

@Test
public void test4() {
    Consumer<Double> con = x -> System.out.println("接收的数字为:" + x);
    con.accept(1000.0);

    Supplier<Integer> sup = () -> (int) Math.random() * 100 ;
    System.out.println(sup.get());

    Function<String, String> fun = s -> {
        System.out.println("接收的字符串为" + s);
        return s.toUpperCase();
    };
    System.out.println(fun.apply("i love china"));

    Predicate<String> p = s -> s.length() > 5;
    System.out.println(p.test("12321s"));
}

其他函数式接口

|

方法引用与构造器应用

当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！
如:

Consumer<String> con1 = s -> System.out.println(s);
// 可以使用方法引用
Consumer<String> con2 = System.out::println

方法引用：使用操作符 “::” 将方法名和对象或类的名字分隔开来。
注意: 方法引用方法的参数列表，必须实现抽象方法的参数列表与保持一致
方法引用有三种方式:

1. 对象::实例方法
2. 类::静态方法
3. 类::实例方法

方法引用的三种方式

1. 对象::实例方法

 @Test
 public void test1() {

     String s = "helloworld";
     Supplier<String> sup = s::toUpperCase;
     System.out.println(sup.get());
 }

2. 类::静态方法

 @Test
 public void test2() {
     BiFunction<Double, Double, Double> bf = Math::max;
     System.out.println(bf.apply(222.0, 3333.0) );
 }

3. 类::实例方法
   若Lambda 的参数列表的第一个参数，是实例方法的调用者，第二个参数(或无参)是实例方法的参数时，可以使用类::实例方法

BiPredicate<String, String> bp = (x, y) -> x.equals(y);
System.out.println(bp.test("abcde", "abcde"));

System.out.println("-----------------------------------------");

BiPredicate<String, String> bp2 = String::equals;
System.out.println(bp2.test("abc", "abc"));

构造器引用

格式： ClassName::new
与函数式接口相结合，自动与函数式接口中方法兼容。可以把构造器引用赋值给定义的方法，接口中抽象方法的参数列表与构造器参数列表一致！

数组引用

格式： type[]::new