Lambda表达式

1.java8新特性 : 函数式接口

什么是函数式接口？

• 只包含一个抽象方法的接口称为函数式接口.该接口可以包含其他非抽象方法.
• 可以通过lambda表达式创建该接口的实现类的对象.(lambda表达式抛出受检异常，那么该异常需要在目标接口的抽象方法上进行声明)
• 我们可以在抽象方法上使用注解，这样做可以检查是否是函数式接口.
• 在java.util.function包下，定义了java8丰富的函数式接口.

2.冗余的匿名内部类与简洁的lambda表达式

例 : 

public class LambdaTest {
    public static void main(String[] args) {
        //实现线程当中提及的Runnable接口,重写了当中的一个抽象方法, 并创建了匿名实现类的对象
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("hexua你太酷啦");
            }
        };
        r1.run();

        //如果我们使用lambda表达式,将会非常简洁
        Runnable r2 = () -> {
            System.out.println("hexua你太酷啦");
        };
        r2.run();
        //运行会发现,两种写法运行结果相同
        //hexua你太酷啦
        //hexua你太酷啦
    }
}

接着我们来介绍一下lambda表达式的语法.

3.lambda表达式的语法

lambda表达式 : 在java8中引入了一种新的语法元素和操作符.即"->".该操作符被称为箭头操作符.它将lambda表达式分为两个部分 ： 

（1）左侧：指定了lambda表达式需要的参数列表.

   (2)  右侧: 指定了lambda体，是抽象方法的实现逻辑.也即lambda表达式要执行的功能.

接下来介绍六种语法格式.

4.语法格式

(1). 无参数, 无返回值类型

@Test
    public void test1() {
        //无参数, 无返回值类型
        Runnable r1 = () -> {
            System.out.println("语法格式-1");
        };
        r1.run();
        //输出和 : 语法格式-1
    }

（2). 需要一个参数, 但是没有返回值

@Test
    public void test2() {
        //需要一个参数, 但没有返回值
        LambdaInterface<String> l1 = (String s) -> {
            System.out.println(s + "tkl");
        };
        l1.show("hexua");
        //输出 : hexuatkl
    }
}
interface LambdaInterface<T> {
    void show(T s);
}

（3). 数据类型可以省略, 因为可以由编译器推断得出, 称为类型推断

@Test
    public void test3() {
        //类型推断, String类型可以省略
        LambdaInterface<String> l1 = (s) -> {
            System.out.println(s + "tkl");
        };
        l1.show("hexua");
        //输出 : hexuatkl
    }
}
interface LambdaInterface<T> {
    void show(T s);
}

(4). 参数列表只有一个参数的情况下, 小括号可以省略

@Test
    public void test4() {
        //参数列表只有一个参数的情况下, 圆括号也可以不写
        LambdaInterface<String> l1 = s -> {
            System.out.println(s + "tkl");
        };
        l1.show("hexua");
        //输出 : hexuatkl
    }
}
interface LambdaInterface<T> {
    void show(T s);
}

(5). 需要两个或两个以上的参数时，多条执行语句, 并且可以有返回值

@Test
    public void test5() {
        LambdaInterface<String> l1 = (s, t) -> {
            System.out.println("我也不知道这里写什么");
            return s + "你过来啊" + t;
        };
        System.out.println(l1.show("hexua", "hexi"));
        //输出 : 我也不知道这里写什么
        //hexua你过来啊hexi
    }
}
interface LambdaInterface<T> {
    String show(T s, String t);
}

(6). 若只有一条语句, return和大括号都可以省略

@Test
    public void test6() {
        //只有一条语句时, return与大括号若有, 都可以省略
        LambdaInterface l2 = () -> "return与大括号都可以省略";//返回值语句
        System.out.println(l2.show());
        //输出 : return与大括号都可以省略
    }
}
interface LambdaInterface<T> {
    String show();
}

5.(重点)四种常见的函数式接口

(1). 消费型接口 : 对类型为T的对象应用操作, 包含方法void accept(T t).

Consumer<T>
抽象方法 : void accept(T t)

(2). 供给型接口 : 返回类型为T的对象, 包含方法T get().

Supplier<T>
抽象方法 : T get()

(3). 函数型接口 : 对类型为T的对象应用操作, 并返回类型为R的对象. 包含方法R apply(T t)

Function<T, R>
抽象方法 : R apply(T t)

(4). 判断型接口 : 确定类型为T的对象是否满意某约束, 并返回boolean值, 包含方法boolean test(T t)

Predicate<T>
抽象方法 : boolean test(T t)