47. java8 新特性--Lambda表达式 / 方法引用

java8 新特性

特点：

• 速度更快
• 代码更少(增加了新的语法： Lambda 表达式)
• 强大的 Stream API
• 便于并行
• 最大化减少空指针异常： Optional
• Nashorn引擎，允许在JVM上运行JS应用

一、Lambda表达式

Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。(Lambda的本质就是函数式接口的实例，因此，要想使用Lambda表达式就必须使用函数式接口。)

/**
 * @author eden
 * @Description
 *   左 -> 右  ：(s1, s2) -> s1.compareTo(s2)
 *   ->：lambda操作符
 *   左边表示的是lambda形参列表
 *   右边表示的是lambda体：重写的抽象方法的方法体
 *  语法格式见下述demo
 *
 * @create projectTest-com.senior.newtest:2021-05-15-12:43
 * @since
 */
public class NewTest {
    //Lambda语法格式
    @Test
    public void lambdaTest(){
        //语法格式一： 无参，无返回值
        Runnable r1 = () -> System.out.println("Lambda语法格式一");
        r1.run();
        //语法格式二： Lambda 需要一个参数，但是没有返回值
        Consumer<String> c1 = (String s) -> { System.out.println(s);};
        c1.accept("test2语法格式二");
        //语法格式三： 数据类型可以省略，因为可由编译器推断得出，称为“类型推断”
        Consumer<String> c2 = (s) -> { System.out.println(s);};
        c2.accept("test3语法格式三");
        //语法格式四： Lambda 若只需要一个参数时， 参数的小括号可以省略
        Consumer<String> c3 = s -> { System.out.println(s);};
        c3.accept("test4语法格式四");
        //语法格式五： Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值
        Comparator<Integer> com = (x,y) -> {
            System.out.println("test4语法格式四");
            return Integer.compare(x,y);
        };
        System.out.println(com.compare(44,43));
        //语法格式六： 当 Lambda 体只有一条语句时， return 与大括号若有，都可以省略
        Comparator<Integer> com1 = (x,y) ->  Integer.compare(x,y);
        System.out.println(com1.compare(12, 54));


    }

    @Test
    public void test(){
        new Runnable() {
            @Override
            public void run() {
                System.out.println("runable 的方法");
            }
        }.run();

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

        Runnable r = () -> System.out.println("test lambda");
        r.run();

        Comparator<Integer> com = (i1, i2) -> Integer.compare(i1,i2);
        int compare = com.compare(12, 23);

        Comparator<String> com1 = (s1, s2) -> s1.compareTo(s2);
        int compare1 = com1.compare("name","nama");
        System.out.println(compare1);

    }
}

只包含一个抽象方法的接口叫做函数式接口。

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

    //根据某种规则过滤String List
    @Test
    public void test1()
    {
        List<String> strs = Arrays.asList("MIT","Oxford","Standard","TsingHua");


        List<String> stringList = filterString(strs, s -> {
            return s.contains("ing");
        });
        System.out.println(stringList);

    }
    //根据某种规则过滤String List
    public List<String> filterString(List<String> strs, Predicate<String> pre){
        ArrayList<String> arrayList = new ArrayList<>();

        for(String s:strs)
        {
            if(pre.test(s))
            {
                arrayList.add(s);
            }
        }
        return arrayList;
    }

---

方法引用

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

构造器引用

        //构造器引用
        //Function<T,R> R是我们想要创建的类的对象，T是该类构造器的输入参数
        //String类中提供了一个构造器是public String(char value[])
        Function<char[], String> fun1 = String::new;
        
        String str = "PhD";
        char[] chars = new char[5];
        chars = str.toCharArray();
        
        String test = fun1.apply(chars);
        System.out.println(test);

数组引用

        Function<Integer,Integer[]> fun = Integer[]::new;
        Integer[] apply = fun.apply(5);
        System.out.println(apply.length);
        apply[0] = 1;
        for(Integer i:apply)
        {
            System.out.println(i);
        }

该博客图片来源于尚硅谷宋老师教学课件