Java8新特性（Lambda 表达式的用法）

一、lambda表达式的实例

1.Lambda表达式是基于推断系统, 从左向右推断
2.Lambda省略了new 接口名() {}
3.省略方法的修饰符, 方法名.
4.省略参数的数据类型, 方法体中只有一个语句时,省略方法体的{}, return 也省略, 因为右面代5.表的就是输出.

6.只有一个参数时, ()也省略

7.lambda表达式只能和函数式接口配合
8.只有一个抽象方法的接口称为函数式接口

public static void main(String[] args) {
        //匿名内部类
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println(" Hello World！！！");
            }
        };
        r1.run();

        //Lambda 表达式
        Runnable r2=()-> System.out.println(" Hello Lambda!!!" );
        r2.run();
    }

注意：Lambda 表达式必须要在main方法中执行，不能在Text单元测试中执行

二、Lambda表达式的一些语法 

语法格式一：无参无返回值

 语法格式二：有一个参，无返回值

 语法格式三：数据类型可以省略，因为编译器可以通过类型推断得出

 语法格式四：Lambda 若只需要一个参数时，参数的小括号可以省略

 

 语法格式五：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值

 

 语法格式六：当 Lambda 体只有一条语句时，return 与大括号若有，都可以省略

 三、Java内置四大函数式接口

函数式接口	参数类型	返回类型	用途
Consumer<T> 消费型接口	T	void	对类型为T的对象应用操作，包含方法： void accept(T t)

public void exer1() {
        Student s = new Student(5, "小伟", 5, 80);
            //内名内部类的写法
        Consumer<Student> consumer1 = new Consumer<Student>() {
            @Override
            public void accept(Student student) {
                System.out.println(student);
            }
        };
        consumer1.accept(s);
            //Lambda 表达式写法
        Consumer<Student> consumer2 = a -> System.out.println(a);
        consumer2.accept(s);
    }

Supplier<T> 供给型接口

无

T

返回类型为T的对象，包含方法：T get()

 @Test
    public void test2() {
        //匿名内部类的写法
        Supplier<String> supplier1 = new Supplier<String>() {
            @Override
            public String get() {
                return "aldksjflaksdf";
            }
        };
        String s1 = supplier1.get();
        System.out.println(s1);

         //Lambda表达式的写法
        Supplier<Double> supplier2 = () -> Math.random();
        Double s2 = supplier2.get();
        System.out.println(s2);
    }

Function<T, R> 函数型接口

T

R

对类型为T的对象应用操作，并返回结果。结果是R类型的对象。包含方法：R apply(T t)

 @Test
    public void test3() {
        //匿名内部类的写法
        Function<String, Integer> function1 = new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return new Integer(s);
            }
        };
        Integer i1 = function1.apply("32842");
        System.out.println(i1);
        
        //Lambda 表达式的写法
        Function<Integer, String> function2 = t -> String.valueOf(t);
        String s2 = function2.apply(8234234);
        System.out.println(s2);
    }

Predicate<T> 断定型接口

T

boolean

确定类型为T的对象是否满足某约束，并返回 boolean 值。包含方法 boolean test(T t)

 

 @Test
    public void test4() {
        //匿名内部类的写法
        Predicate<Integer> predicate1 = new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer % 2 != 0;
            }
        };
        boolean t1 = predicate1.test(92);
        System.out.println(t1);

        //Lambda表达式的写法
        Predicate<String> predicate2 = t -> t.isEmpty(); // 判定字符串是否为空串.
        boolean t2 = predicate2.test("");
        System.out.println(t2);
    }