Java8的Lambda表达式

Lambda是一个匿名函数，可以把Lambda表达式理解为一段可以传递的代码。通过Lambda表达式可以写出更简洁、更灵活的代码，提升了Java语言的表达能力。

从匿名类到Lambda的转换

Java8之前的匿名内部类：

Comparator<Integer> com = new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        // TODO Auto-generated method stub
        return Integer.compare(o1, o2);
    }
};

使用Lambda表达式代替匿名内部类：

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

Lambda表达式语法

Java8中引入了一个新的操作符 “->” 该操作符称为箭头操作符或 Lambda 操作符箭头操作符将 Lambda 表达式拆分成两部分：
左侧：Lambda 表达式的参数列表
右侧：Lambda 表达式中所需执行的功能， 即 Lambda 体

• 语法格式一：无参数，无返回值

() -> System.out.println("Hello Lambda!");

• 语法格式二：有一个参数，并且无返回值

(x) -> System.out.println(x)

• 语法格式三：若只有一个参数，小括号可以省略不写

x -> System.out.println(x)

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

Comparator<Integer> com = (x, y) -> {
    System.out.println("函数式接口");
    return Integer.compare(x, y);
};

• 语法格式五：若 Lambda 体中只有一条语句， return 和 大括号都可以省略不写

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

• 语法格式六：Lambda 表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即“类型推断”

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

函数式接口

通过在任意函数式接口上使用@FunctionalInterface注解可以检查它是否为一个函数式接口。
自定义接口：

@FunctionalInterface
public interface MyFun {
    public Integer getValue(Integer num);
}

作为参数传递Lambda表达式：

public void test() {
    Integer num = operation(100, (x) -> x * x);
    System.out.println(num);
    System.out.println(operation(200, (y) -> y + 200));
}
public Integer operation(Integer num, MyFun mf) {
    return mf.getValue(num);
}

Java8 内置的四大核心函数式接口

• Consumer : 消费型接口

void accept(T t);

案例：

public void test() {
    happy(1000, (m) -> System.out.println("消费：" + m + "元"));
}
public void happy(double money, Consumer<Double> con) {
    con.accept(money);
}

• Consumer : Supplier : 供给型接口

T get(); 

案例：

public void test() {
    List<Integer> numList = getNumList(10, () -> (int)(Math.random()*100));
    for (Integer num : numList) {
        System.out.println(num);
    }
}   
public List<Integer> getNumList(int num, Supplier<Integer> sup) {
    List<Integer> list = new ArrayList<Integer>();
    for(int i=0; i<num; i++) {
        Integer n = sup.get();
        list.add(n);
    }
    return list;
}

• Function

R apply(T t);

案例：

public void test() {
    String newStr = strHandler("\t\t\t Java   ", (str) -> str.trim());
    System.out.println(newStr);

    String subStr = strHandler("Java", (str) -> str.substring(1, 3));
    System.out.println(subStr);
}
public String strHandler(String str, Function<String, String> fun) {
    return fun.apply(str);
}

• Predicate : 断言型接口

boolean test(T t);

案例：

public void test4() {
    List<String> list = Arrays.asList("hello","world","Java");
    List<String> strList = filterStr(list, (s)->s.length()<5);
    for(String str:strList) {
        System.out.println(str);
    }
}
public List<String> filterStr(List<String> list, Predicate<String> pre) {
    List<String> strList = new ArrayList<>();
    for (String str : list) {
        if(pre.test(str)){
            strList.add(str);
        }
    }
    return strList;
}

方法引用与构造器引用

方法引用：若 Lambda 体中的功能，已经有方法提供了实现，可以使用方法引用

方法引用有如下三种使用情况：

• 1.对象的引用 :: 实例方法名

Employee emp = new Employee("张三");
Supplier<String> sup = () -> emp.getName();
System.out.println(sup.get());
System.out.println("-----------------------");  
Supplier<String> sup2 = emp::getName;
System.out.println(sup2.get());

• 2.类名 :: 静态方法名

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

• 3.类名 :: 实例方法名

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

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

构造器引用 :构造器的参数列表，需要与函数式接口中参数列表保持一致

• 类名 :: new

Supplier<Employee> sup = () -> new Employee();
System.out.println(sup.get());
System.out.println("------------------------------");
Supplier<Employee> sup2 = Employee::new;
System.out.println(sup2.get());

数组引用

• 类型[] :: new

Function<Integer, String[]> fun = (args) -> new String[args];
String[] strs = fun.apply(10);
System.out.println(strs.length);

Function<Integer, String[]> fun2 = String[]::new;
String[] strs2 = fun2.apply(20);
System.out.println(strs2.length);