Java 8 新特性

Java 8 新特性

Lambda

格式

• -> Lambda 操作符 or 箭头操作符
• -> 左边 lambda 形参列表 - 接口中的抽象方法的形参列表
• -> 右边 lambda 方法体

Lambda 表达式的 本质，就是做为接口的实列，接口中只能有一个抽象方法，也叫函数式接口

    @Test
    public void test1()  {

        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println(\" 1 run() ... \");
            }
        };
        r.run();

        Runnable r1 = () -> System.out.println(\" 2 run() ... \");
        r1.run();
    }

    @Test
    public void test2() {

        Comparator<Integer> c = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };
        System.out.println(c.compare(1,2));

        Comparator<Integer> c1 = (o1,o2) -> Integer.compare(o1,o2);
        System.out.println(c1.compare(2,1));
    }

    @Test
    public void test3() {
        Consumer<String> c = s -> System.out.println(s);
        c.accept(\"HI Java ... \");
    }

函数式接口

java.util.function 包下定义 JDK 8 的 函数式接口

Consumer 消费型 void accept(T t)

Supplier 供给型 T get()

Function<T,R> 函数型 R apply(T t)

Predicate 断言型 boolean test(T t)

方法引用

方法引用，本质上就是 Lambda 表达式，而 Lambda 表达式 作为函数式接口的实例

方法引用 = 函数式接口的实例

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

格式：类 or 对象 ：：方法名 System.out::println

对象：：非静态 类：：静态

    @Test
    public void test4() {

        /*
            Consumer -  void accept(T t)
            System.out - void println(T t)
         */
        Consumer<String> c = System.out::println;
        c.accept(\" 方法引用 \");

        List<String> list = new ArrayList<>();
        list.add(\"张三\");
        list.add(\"李四\");

        /*
            Supplier - T get()
            List - String toString()
         */
        Supplier<String> s = () -> list.toString();
        System.out.println(s.get());

        Supplier<String> s1 = list::toString;
        System.out.println(s1.get());
        
        /*
            1 传入类型 2 返回类型
         */
        Function<Double,Long> f = Math::round;
        System.out.println(f.apply(5.0));
    }

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

类：：非静态

    @Test
    public void test5() {

        /*
            Comparator - int compare(T t1,T t2)
            String - int t1.compareTo(t2)

            第一个参数 作为调用者
            第二个参数 传入者
         */
        Comparator<String> c = String::compareTo;
        c.compare(\"a\",\"b\");

        /*
            Bipredicate - boolean test(T t1,T t2)
            String - boolean t1.equest(t2)
         */
        BiPredicate<String,String> biPredicate = String::equals;
        biPredicate.test(\"a\",\"b\");

        /*
            第一个参数 做调用者
            Funcation - R apply(T t)

            String - String toString()

         */
        Function<String,String> f = String::toString;
        f.apply(\"Hi Java\");
    }

构造器引用 和 数组引用

    @Test
    public void test6() {

        /*
            1 构造器引用
            2 数组引用
         */
         Supplier<ArrayList> supplier = ArrayList::new;
         System.out.println(supplier.get());

         Function<char[],String> f = String::new;
         System.out.println(f.apply(new char[]{\'1\',\'2\',\'3\'}));

         BiFunction<byte[],Integer,String> bif = String::new;
         System.out.println(bif.apply(new byte[16],16));

         Function<Integer,String[]> f2 = String[]::new;
         System.out.println(Arrays.toString(f2.apply(3)));
    }

Optional

java.util.Optional<T> 是一个容器类，可以避免空指针异常

Stream API

java.util.stream.Stream 对集合数据操作，一种高效的处理数据的方式，类似数据库查询；

JDK 8 Collection 扩展了两个获取 Stream 的方法，1 顺序流 2 并行流

    @Test
    public void test1() { // Stream 方式一：通过集合
        // 顺序流
        Stream<User> stream = getList().stream();

        stream.skip(1) // 跳过几个元素，元素个数不足时 返回 空流 配合 limit(n) 使用
                .filter(o -> o.getAge() > 1) // 通过条件过滤
                .distinct() // 过滤 通过 hashCode 和 equest 元素去重
                .limit(3) // 截断流
                .forEach(System.out::println); // 终止操作


        // 并行流
        Stream<User> parallelStream = getList().parallelStream();
    }

使用java.util.Arrays.stream(T[] array)方法用数组创建流

int[] array={1,3,5,6,8};
IntStream stream = Arrays.stream(array);

使用Stream的静态方法：of()、iterate()、generate()

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);

Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 3).limit(4);
stream2.forEach(System.out::println);

Stream<Double> stream3 = Stream.generate(Math::random).limit(3);
stream3.forEach(System.out::println);

来源：https://www.cnblogs.com/oioi/p/15969312.html
本站部分图文来源于网络，如有侵权请联系删除。