Java8新特性

目录

一：lambda表达式

1:什么是函数式接口：

2:lambda书写规则：

二：Stream流

1:stream流的创建方式:

2:利用stream流将list转换为set：

3:利用stream流将list转换为map

4:stream流的max 与 min 方法求最大最小值

5:stream流的match 匹配

6:stream流的forEach循环

---

一：lambda表达式

lambda表达式的主要作用：简化我们匿名内部内的调用

lambda表达式规范：要使用lambda表达式必须是函数式接口，也就是只有函数式接口才能用 lambda表达式书写

1:什么是函数式接口：

        1：在接口中只有一个抽象方法

        2：可以定义Obiect类中的方法

        3：@FunctionalInterface 注解表示该接口为函数接口

列如 java.io.FileFilter

2:lambda书写规则：

        ()  //参数列表

        ->  //分隔符

        {}  //方法体

(参数列表 不需要写类型 只需定义参数名) -> {方法体}

注意：lambda表达式返回的是接口实例对象

 

二：Stream流

        

先将list对转换成stream流，然后再进行(去重，排序，遍历，转换等操作) 非常精简与方便

 

1:stream流的创建方式:

 ArrayList<Object> list = new ArrayList<>();
        list.add("zhangsan");
        list.add("lisi");
        list.add("wangwu");
        list.add("zhaoliu");
        Stream<Object> stream = list.stream();//将list转换为stream流

2:利用stream流将list转换为set：

ArrayList<Object> list = new ArrayList<>();
        list.add("zhangsan");
        list.add("lisi");
        list.add("wangwu");
        list.add("zhaoliu");
        Stream<Object> stream = list.stream();//将list转换为stream流
        Set<Object> set = stream.collect(Collectors.toSet());//将list转换为set

3:利用stream流将list转换为map

 ArrayList<Object> list = new ArrayList<>();
        list.add("zhangsan");
        list.add("lisi");
        list.add("wangwu");
        list.add("zhaoliu");
        Stream<Object> stream = list.stream();//将list转换为stream流
        /**
         * 将list转换为map
         */
        stream.collect(Collectors.toMap(new Function<Object, Object>() {
            @Override
            public Object apply(Object kay) {
                return kay;
            }
        }, new Function<Object, Object>() {
            @Override
            public Object apply(Object value) {
                return value;
            }
        }));

        /**
         * 使用lambda表达式将list转换为map（简化匿名内部类的调用）
         */
        stream.collect(Collectors.toMap(e->{return e;},e->{return e;}));

4:stream流的max 与 min 方法求最大最小值

 ArrayList<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(30);
        list.add(20);
        list.add(60);

        /**
         * stream流的min方法求最小值
         */
        Optional<Integer> min = list.stream().min(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
        System.out.println(min.get());

        /**
         * lambda表达式写法（简化匿名内部类的调用）
         */
        Optional<Integer> min1 = list.stream().min((e1, e2) -> {
            return e1 - e2;
        });
        System.out.println(min1.get());

5:stream流的match 匹配

        anyMatch：判断的条件里，任意元素满足，返回true

        allMatch：判断的条件里所有元素都满足，返回true

        noneMatch：判断的条件里所有元素都不满足，返回true

ArrayList<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(30);
        list.add(20);
        list.add(60);

        /**
         * 任意一个元素等于20 则返回true
         */
        boolean b = list.stream().anyMatch(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer == 20;
            }
        });
        System.out.println(b);//true

        /**
         * 所有元素等于20 则返回true
         */
        boolean b1 = list.stream().allMatch(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer == 20;
            }
        });
        System.out.println(b1);//false

        /**
         * 所有元素都不等于20 则返回true
         */
        boolean b2 = list.stream().noneMatch(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer == 20;
            }
        });
        System.out.println(b2);//false
        
        

//lambda表达式写法

        /**
         * 任意一个元素等于20 则返回true
         */
        boolean b = list.stream().anyMatch(integer -> {return integer == 20;});
        System.out.println(b);//true

        /**
         * 所有元素等于20 则返回true
         */
        boolean b1 = list.stream().allMatch(integer -> {return integer == 20;});
        System.out.println(b1);//false

        /**
         * 所有元素都不等于20 则返回true
         */
        boolean b2 = list.stream().noneMatch(integer -> {return integer == 20;});
        System.out.println(b2);//false

6:stream流的forEach循环

 ArrayList<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(30);
        list.add(20);
        list.add(60);

        /**
         * 遍历list集合
         */
        list.stream().forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println(integer);
            }
        });

        /**
         *  lambda表达式写法 遍历list集合
         */
        list.stream().forEach(integer -> {
            System.out.println(integer);
        });