lambda表达式（lambda表达式的简化、函数式接口）

lambda表达式

一、Lambda简介

       Lambda 表达式是 JDK8 的一个新特性，可以取代大部分的匿名内部类，写出更简洁的 Java 代码，尤其在集合的遍历和其他集合操作中，可以极大地优化代码结构。
       JDK 也提供了大量的内置函数式接口供我们使用，使得 Lambda 表达式的运用更加方便、高效。

二、对接口的要求

       虽然使用 Lambda 表达式可以对某些接口进行简单的实现，但并不是所有的接口都可以使用 Lambda 表达式来实现。Lambda 规定接口中只能有一个需要被实现的方法，但不是说接口中只能有一个方法。

三、lambda的基础语法

       语法形式为 () -> {}，其中 () 用来描述参数列表，{} 用来描述方法体，-> 为 lambda运算符 。
       如果只有一个参数时()可以省略，方法体只有返回值或只有一行代码时{}可以省略，例如消费型与供给型接口所示。

四、四大函数型接口lambda表达式示例

• 查看非lambda代码的四大函数型接口点击此处
• 以下为lambda代码简化后的函数式接口示例

public static void main(String[] args) {
        //消费型
        //consumertest(10000,(i) -> {System.out.println("消费了："+i+"元");});
        consumertest(10000,i -> System.out.println("消费了："+i+"元"));

        //供给型
        //System.out.println(getValue(() -> {
        //    return (int) (Math.random() * 10) + 1;
        //}));
        System.out.println(getValue(()->(int)(Math.random()*10)+1));

        //方法型
        System.out.println(functiontest("    哈哈    ", (str) -> str.trim()));

        //断言型
        List<Integer> list = new ArrayList<>();
        list.add(300);
        list.add(3);
        list.add(30);
        list.add(3333);
        list.add(30033);
        List<Integer> list1 = predicatetest(list,(li)->li>100);
        System.out.println(list1);

    }

    //消费型接口
    public static void consumertest(Integer i, Consumer<Integer> com){
        com.accept(i);
    }

    //供给型
    public static Integer getValue(Supplier<Integer> s){
        return s.get();
    }

    //方法型
    public static String functiontest(String str,Function<String,String> fun){
        return fun.apply(str);
    }

    //断言型
    public static List<Integer> predicatetest(List<Integer> list, Predicate<Integer> pre){
        List<Integer> newlist = new ArrayList<>();
        for (Integer i : list) {
            if (pre.test(i)){
                newlist.add(i);
            }
        }
        return newlist;
    }

五、lambda表达式的简化

语法：
       方法引用: 简化Lambda–>Lambda表达式特殊的一种表现形式当lambda体中的实现是通过调用另外一个方法实现的时候,这个方法的参数列表和返回值类型与抽象方法的参数列表与返回值一致的时候,就可以使用方法引用进行代替。
       方法引用分为：
              引用::成员方法名
              类名::静态方法名
              类名::成员方法名

public static void main(String[] args) {
        List<String> list = new ArrayList();
        list.add("123");
        list.add("12");
        list.add("1");
        //引用::成员方法名
        //遍历容器,打印里面的每一个数据
        list.forEach((i)->{
            System.out.println(i);
        });
        //Lambda体实现的功能就是打印参数-->可以通过方法引用来代替
        //通过PrintStream这个类型的对象调用println实现的,
    	//Lambda的抽象方法的参数作为println方法的参数,两者都没有返回值
        PrintStream ps = System.out;
        list.forEach(ps::println);

        list.forEach(System.out::println);

        //类名::静态方法名
        //比较2个double参数,返回最大的一个
        //2个参数 1个返回值  BiFunction
        //求最大值r
    	//lambda表达式
        //BiFunction<Double,Double,Double> fun = (d1, d2)->Math.max(d1,d2);
        //lambda的简化
    	BiFunction<Double,Double,Double> fun = Math::max;
        
    	System.out.println(fun.apply(100.0, 200.0));

        //比较两个int类型的参数
        Comparator<Integer> com = (i1, i2)->Integer.compare(i1,i2);
        //lambda简化
    	com = Integer::compare;
        System.out.println(com.compare(12, 13));

        //比较两个字符串是否相等
        BiPredicate<String,String> pre = (s1,s2)-> s1.equals(s2);
        //1)lambda是否是通过引用另外一个方法实现的->是  
    	//2)返回值匹配  
    	//3)抽象方法第一个参数s1作为内部引用另一个方法的对象存在,
    	//	如果抽象方法存在多个参数,第二个参数开始匹配内部引用的方法的参数列表-->方法引用
        pre = String::equals;
        System.out.println(pre.test("zhangsan", "zhangsan"));

    	//类名::成员方法名
        //获取bean中的属性
        Employee e = new Employee("ggh",12);
        Supplier<String> sup = ()->e.getName();
        sup = e::getName;   //对象固定
        System.out.println("名字为："+sup.get());

        Function<Employee,String> func = (em)-> em.getName();
        func = Employee::getName;   //对象可变
        System.out.println(func.apply(e));
    }