Java8 Lambda表达式和Stream流处理，看这篇就够了

逃离我推掉我的手 2022-02-03 16:19 251阅读 0赞

**Java 8提供的Lambda表达式和Stream能够帮我们简化代码，让我们可以写出更优雅、简洁的代码。话不多说，上代码**

/**
     * @Author: guandezhi
     * @Date: 2019/5/9 17:38
     */
    public class LambdaTest {
    
        public static void main(String[] args) {
    
            List<Integer> lists = Arrays.asList(2, 3, 4, 5, 6, 1, 7, 8, 9);
    
            //第一种写法（未使用lambda表达式）
            List<Integer> newLists1 = lists.stream()
                    .filter(new Predicate<Integer>() {
                        @Override
                        public boolean test(Integer integer) {
                            return !integer.equals(1);
                        }
                    })
                    .limit(6)
                    .sorted(new Comparator<Integer>() {
                        @Override
                        public int compare(Integer o1, Integer o2) {
                            return o2 - o1;
                        }
                    }).map(new Function<Integer, Integer>() {
                        @Override
                        public Integer apply(Integer list) {
                            Integer m = list;
                            if (list == 1) {
                                m = 10;
                            }
                            return m;
                        }
                    }).collect(Collectors.toList());
    
    
            //第二种写法
            List<Integer> newLists2 = StreamSupport.stream(lists.spliterator(), false)
                    .filter(x -> {
                        return !x.equals(1);
                    })
                    .limit(6)
                    .sorted((o1, o2) -> {
                        return o2 - o1;
                    })
                    .map(list -> {
                        Integer m = list;
                        if (list == 1) {
                            m = 10;
                        }
                        return m;
                    }).collect(Collectors.toList());
    
    
            //第三种写法
            List<Integer> newLists3 = lists.stream()
                    .filter(x -> {
                        return !x.equals(1);
                    })
                    .limit(6)
                    .sorted((o1, o2) -> {
                        return o2 - o1;
                    })
                    .map(list -> {
                        Integer m = list;
                        if (list == 1) {
                            m = 10;
                        }
                        return m;
                    }).collect(Collectors.toList());
    
            System.out.println("newLists1:" + newLists1 + "\n" + "newLists2:" + newLists2 + "\n" + "newLists3:" + newLists3);
    
    
            //第四种写法
            StreamSupport.stream(lists.spliterator(), false)
                    .filter(x -> {
                        return !x.equals(1);
                    })
                    .limit(6)
                    .sorted((o1, o2) -> {
                        return o2 - o1;
                    })
                    .map(list -> {
                        Integer m = list;
                        if (list == 1) {
                            m = 10;
                        }
                        return m;
                    }).collect(Collectors.toList()).forEach(System.out::println);
        }
    }

** 结果如下：**

newLists1:[7, 6, 5, 4, 3, 2]
    newLists2:[7, 6, 5, 4, 3, 2]
    newLists3:[7, 6, 5, 4, 3, 2]
    7
    6
    5
    4
    3
    2

**总结：**

**  1.代码涉及Stream中的foreach、map、filter、sort、limit。**

**  2.代码涉及lambda表达式 ->(匿名函数)以及::（方法调用）。**

**  3.如果不知道如何转换成lambda表达式，可以先用匿名函数完整的写出，利用idea快alt+enter转换成lambda表达式。**