16.Java其他新特性

Lambda表达式

使用lambda表达式前后区别

@Test
public void test1(){
    Runnable r1=new Runnable() {
        @Override
        public void run() {
            System.out.println("我测尼玛");
        }
    };
    r1.run();
    System.out.println();
    Runnable r2=() -> System.out.println("我测尼玛");
    r2.run();
}
@Test
public void Test2(){
    Comparator<Integer> comparable=new Comparator<Integer>() {
        @Override
        public int compare(Integer o1,Integer o2) {
            return Integer.compare(o1,o2);
        }
    };
    int compare = comparable.compare(32, 21);
    System.out.println(compare);


    Comparator<Integer> comparable1=(o1,o2) -> Integer.compare(o1,o2);
    int compare1 = comparable1.compare(32, 21);
    System.out.println(compare1);

    Comparator<Integer> comparable2=Integer :: compare;
    int compare2 = comparable2.compare(32, 21);
    System.out.println(compare2);
}

Lambda表达式的使用

1.举例（o1,o2）-> Integer.compare(o1,o2);

2.格式：

​ ->:Lambda表达式的操作符

​ 左边：lambda形参列表，其实就是接口中的抽象方法的形参列表

​ 右边：lambda体，其实就是重写的抽象方法的方法体

3.Lambda表达式的使用：6种

4.Lambda表达式的本质，作为函数式接口的实例

5.如果接口只有一个抽象方法，此接口就是函数式接口

在一个接口上使用@FunctionalInterface注解，表示它是一个函数式接口

以前用匿名实现类表示的现在都可以用Lambda表达式来写

总结：

1. 左边：Lambda参数列表的参数类型都可以省略，如果只有一个参数，（）也可以省略
2. 右边：Lambda体应该使用{}包裹，如果Lambda只有一条语句（可能是return），可以省略{}，return

六种形式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xfCytm78-1665566586793)(C:\Users\zhangshuaibao\AppData\Roaming\Typora\typora-user-images\image-20221012155043126.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lVj41QtP-1665566586795)(C:\Users\zhangshuaibao\AppData\Roaming\Typora\typora-user-images\image-20221012155058747.png)]

函数式接口

如果接口只有一个抽象方法，此接口就是函数式接口

在一个接口上使用@FunctionalInterface注解，表示它是一个函数式接口

当需要对一个函数式接口实例化时，可以使用lambda表达式

Java内置的4大核心函数式接口

• 消费型接口 Consumer void accept(T t)
• 供给型接口 Supplier T get()
• 函数型接口 Function R apply(T t)
• 断定型接口 Predicate boolean test(T t)

何时使用函数接口？

​ 如果开发中需要定义一个函数式接口，首先看在已有的jdk提供的函数式接口是否提供了能满足需求的函数式接口，如果有，则直接调用，不需要自己自定义

方法引用

使用情景：当要传递给lambda体的操作，已经实现的方法了，可以使用方法引用

理解：方法引用可以看作lambda表达式深层次的表达。换句话说，方法引用就是lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法

情况：

​ 对象：：非静态方法

​ 类：：静态方法

​ 类：：非静态方法

要求：接口中的抽象方法形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同

当函数式接口方法的第一个参数是需要引用方法的调用者，并且第二个参数是需要引用方法的参数（或无参数）时：ClassName：：methodName

使用建议：如果给函数式接口提供实例，切好满足方法引用的使用情景，可以使用方法引用给函数式接口提供实例

StreamAPI

理解：Stream关注的是对数据的运算，与CPU打交道，集合关注的是数据的存储，与内存打交道

注意点：

• Stream自己不会存储元素
• Stream不会改变源对象，相反，他们会返回一个持有结果的新Stream
• Stream操作是延迟执行的，这意味着他们会等到需要结果的时候才会执行

Stream的使用流程：

• Stream的实例化

//创建Stream方式一：通过集合
    @Test
    public void Test1(){
        List<Employee> employees = EmployeeData.getEmployees();
        //default Stream stream() 返回一个顺序表
        Stream<Employee> stream=employees.stream();
        //default Stream parallelStream() 返回一个并行流
        Stream<Employee> employeeStream = employees.parallelStream();

    }
    //创建Stream方式二：通过数组
    @Test
    public void Test2(){
        int[] arr={1,2,3,4,5,6};
        //调用Arrays类的static Stream stream(T[] array):返回一个流
        IntStream stream = Arrays.stream(arr);
        Employee e1=new Employee(1001,"Tom");
        Employee e2=new Employee(1002,"Jerry");
        Employee[] employees = {e1, e2};
        Stream<Employee> stream1 = Arrays.stream(employees);
    }
    //创建Stream方式三：通过Stream的of（）
    @Test
    public void Test3(){
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6);

    }
    ///创建Stream方式四：创建无限流
    @Test
    public void Test4(){
//        迭代
//        public staic Stream iterable(final T seed,final UnaryOperator f)
        //遍历前10个偶数
        Stream.iterate(0,t ->t+2).limit(10).forEach(System.out::println);
//        生成
//        public static  Stream generate(Supplier s)
        Stream.generate(Math::random).limit(10).forEach(System.out::println);
    }

• 一系列的中间操作（过滤、映射、。。。）

使用流程的注意点：

• 1.一个中间操作链，对数据源的数据进行处理
• 2.一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

Optional类的使用

理解：为了在程序中避免出现空指针异常而创建的

常用方法：

• ofNullable(T t)
• orElse(T t)

例子：

@Test
    public void Test1(){
        Girl girl = new Girl();
        girl=null;
        //of(T t):保证t是非空的
        Optional<Girl> optionalGirl = Optional.of(girl);

    }
    @Test
    public void Test2(){
        Girl girl = new Girl();
        girl=null;
        //ofNullable(T t)：t可以为null
        Optional<Girl> optionalGirl = Optional.ofNullable(girl);
        System.out.println(optionalGirl);

    }
    public String getGirlName(Boy boy){
        return boy.getGirl().getName();
    }
    @Test
    public void Test3(){
        Boy boy=new Boy();
        boy=null;
        String girlName=getGirlName(boy);
        System.out.println(girlName);
    }
    //优化
    public String getGirlName1(Boy boy){
        if(boy!=null){
            Girl girl=boy.getGirl();
            if(girl!=null){
                return girl.getName();
            }
        }
        return null;
    }
    @Test
    public void Test4(){
        Boy boy=new Boy();
        boy=null;
        String girlName=getGirlName1(boy);
        System.out.println(girlName);
    }
    @Test
    public void Test5(){
        Girl girl = new Girl();
//        girl=null;
        //ofNullable(T t):t可以为null
        Optional<Girl> girl1 = Optional.ofNullable(girl);
        //orElse(T t1):如果当前的Optional内部疯传的t是非空的，则返回内部的t
        //如果内部的t是空的，则返回orElse方法中的t1
        Girl orElse = girl1.orElse(new Girl("丁真"));
        System.out.println(orElse);
    }
    //使用Optional
    public String getGirlName2(Boy boy) {
        Optional<Boy> boyOptional=Optional.ofNullable(boy);
        Boy boy1 = boyOptional.orElse(new Boy(new Girl("迪丽热巴")));
        Girl girl = boy1.getGirl();
        Optional<Girl> girlOptional=Optional.ofNullable(girl);
        Girl girl1 = girlOptional.orElse(new Girl("马儿扎哈"));
        return girl1.getName();
    }
    @Test
    public void Test6(){
        Boy boy=null;
//        boy=new Boy();
//        boy=new Boy(new Girl("丁真"));
        String girlName=getGirlName2(boy);
        System.out.println(girlName);
    }
e(new Girl("马儿扎哈"));
        return girl1.getName();
    }
    @Test
    public void Test6(){
        Boy boy=null;
//        boy=new Boy();
//        boy=new Boy(new Girl("丁真"));
        String girlName=getGirlName2(boy);
        System.out.println(girlName);
    }