Java自学整理3——Java8的新特性

1. 常用函数接口

   1. @FunctionalInterface注解

      可以检测接口是否是一个函数式接口，是，编译成功，否则编译失败（接口中没有抽象方法或抽象方法的个数多于一个）

2. 函数式编程

   1. lambda的延迟执行

      满足条件执行接口，不满足则不执行，这是一种优化

   2. JDK提供了大量常用的函数式编程接口和丰富的lambda的典型应用场景，它们主要在java.util.function包中被提供。

      1. Supplier：只有一个get()方法，返回一个泛型的数据

         ...(Supplier<String>sup){
             return sup.get();
         }
         // 调用
         (()->"hahaha");
         

      2. Consumer：消费一个泛型数据

         (String name, Consumer<String>con){
             con.accept(name);
         }
         

      3. 一个字符串翻转的方法

         String reName = new StringBuffer(name).reverse().toString();
         System.out.println(reName);
         

      4. 默认方法andThen

         con1.andThen(con2).accept(s);

         将两个Consumer接口连接在一起，谁写在前面，谁先消费。

      5. Predicate：返回一个布尔值

         return pre.test(s);

         如果lambda表达式中只有一个参数的话，（）可以省略。

         补充：<? extends A>表示类型必须是A或者A的子类

         ​ <? super A>表示类型必须是A或者A的超类

         三个默认方法：and or negate

      6. Function：转化类型接口，前者称为前置条件，后者称为后置条件。

         int in = fun.apply(s);

         默认方法 andThen

   3. Stream流

      1. 两种获取流的方式

         1. Collection.stream()
         2. Stream.of(T...values) // 可变参数，可传数组

      2. 常用方法

         1. forEach ：使用Consumer接口（延）

            Stream<String>stream = Stream.of("1", "2"..."10");
            stream.forEach(name->System.out.println(name));
            

         2. filter ：使用Predicate接口（延）

            Stream<String>stream = Stream.of("1", "2"..."10");
            String stream2 = stream.filter(name->name.StartsWith("张"));
            stream2.forEach(name->System.out.println(name));
            // stream流只能使用一次，stream调用了filter之后就关闭了，stream不能再使用forEach。
            

         3. map：使用Function接口（延）

            Stream<String>stream = Stream.of("1", "2", "3", "4");
            Stream<Integer>stream2 = stream.map(s->Integer.parseInt(s));
            stream2.forEach(i->System.out.println(i));
            

         4. count：统计个数，返回值为long（终）

            Stream<Integer>stream = list.stream();
            long count = stream.count();
            System.out.println(count);
            

         5. limit：取用前几个，参数是long类型，参数小于等于元素个数，返回新流，否则不操作。（延）

         6. skip：跳过前几个，参数是long类型，流的长度大于当前参数返回新的流，否则返回一个长度为0的空流。

         7. concat：Stream的一个静态方法，可以将两个流合并成一个流。

            补充：list2.addAll(list1);// 将list1中的元素全部加入到list2中。

   4. 方法引用

      1. 方法引用符号："::"

      2. 当对象和方法已经存在，可以直接引用来优化lambda表达式

         1. 通过对象名引用成员方法

            Person p = new Person();
            printString(p::printUpperCaseString);
            

         2. 通过类名引用静态成员方法

            int number2 = method(-10, Math::abs);
            

         3. 通过this引用成员方法

            marry(this::buyHouse);
            

         4. 通过super引用成员方法

            method(super::sayHello);
            

         5. 类的构造器引用

            printName("张三", Person::new);
            

         6. 数组的构造器引用

            int[] arr2 = createArray(10, int[]::new);