java8特性Stream操作集合都現在了還不會用，還不趕緊學？

一、簡簡單單嘮嘮嗑

拖更了四個月的博客真是慚愧，本人年前辭去了上份工作（還是不說前公司壞話了吧），決定年後奔向南方，結果就在家遇上了疫情。現在行情是真的差勁，之前在北京16k 14薪的朋友最近去了杭州，面試了很多家最終還是隻拿到了15.5k，在這裏奉勸各位除非萬不得已千萬不要裸辭，否則可能會找工作找到抑鬱。

本人在4月份入職了996的外包公司，跟我同一天入職的加上我有4個人，其他3個人都受不了壓力，或者覺得天天搬磚學不到東西都離職了 - - 。在上週前公司前端同事告訴我他也離職了，但是離職前在同城市找到了年薪18w的工作，還是跟自己女朋友在同一家公司，羨慕吶。不過雖然我入職了外包但是在5月份通過自己的努力拿到這個月提前轉正的資格，在這個環境下我所能做的就是不停的學習，機會只留給有準備的人呀…真是感慨萬千。

二、安排

public class Java8Test {

    public static void main(String[] args) throws Exception {

        List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");
        List<Integer> numbers = Arrays.asList(0, 2, 2, 3, 7, 3, 5, 10, 24, 1, 22, 19);

        //========創建流
        //list創建流
        Stream<String> stream1 = strings.stream(); //獲取一個順序流
        Stream<String> parallelStream = strings.parallelStream(); //獲取一個並行流
        //數組創建流
        Integer[] nums = new Integer[]{1, 2, 3, 4, 5};
        Stream<Integer> stream2 = Arrays.stream(nums);
        //使用Stream靜態方法創建 of()
        Stream<Integer> stream3 = Stream.of(1, 2, 3, 4, 5, 6);
        //使用Stream靜態方法創建 iterate()
        Stream<Integer> stream4 = Stream.iterate(0, (x) -> x + 2).limit(6);  // 0 2 4 6 8 10
        //使用Stream靜態方法創建 generate()
        Stream<Double> stream5 = Stream.generate(Math::random).limit(2);//0.024200317771542856 0.7243499311986518
        //使用BufferReader
        BufferedReader reader = new BufferedReader(new FileReader("F:\\test_stream.txt"));
        Stream<String> lineStream = reader.lines();
        //直接將字符串切割成流
        Pattern pattern = Pattern.compile(",");
        Stream<String> stringStream = pattern.splitAsStream("a,b,c,d");

        System.out.println("原字符串集合爲：" + strings);
        System.out.println("原數字集合爲：" + numbers);
        System.out.println("===========================");

        //========filter()  filter的意思更像是select 選擇符合條件的而不是去掉符合條件的
        //去除空字符串
        List<String> stringsNotEmpty = strings.parallelStream().filter(p -> !p.isEmpty()).collect(Collectors.toList());
        System.out.println("去掉空字符串後的集合爲：" + stringsNotEmpty);
        //合併字符串 Collectors.joining()
        String stringMerged1 = strings.parallelStream().filter(p -> !p.isEmpty()).collect(Collectors.joining(","));
        String stringMerged2 = strings.parallelStream().filter(p -> !p.isEmpty()).collect(Collectors.joining(""));
        System.out.println("合併字符串元素：" + stringMerged1);
        System.out.println("合併字符串元素：" + stringMerged2);
        //統計空字符串的個數 count()
        long countStringEmpty = strings.parallelStream().filter(String::isEmpty).count();
        System.out.println("字符串集合中的空字符串個數爲：" + countStringEmpty);

        //=======map()
        //將數字數組中的每個數字+1
        List<Integer> addOne = numbers.parallelStream().map(p -> p + 1).collect(Collectors.toList());
        System.out.println("數字集合中每個元素+1，結果爲：" + addOne);
        //List<String>轉換爲List<Map>
        List<Map<String, String>> ListString2ListMap = strings.parallelStream().map(p -> {
            Map<String, String> temp = new HashMap<>();
            temp.put("value", p);
            return temp;
        }).collect(Collectors.toList());
        System.out.println("將字符串集合轉爲Map集合，結果爲：" + ListString2ListMap);

        //=======peek() forEach() 和map()區別就是沒有返回值
        //List<String>轉換爲List<Map>
        HashMap<Integer, String> tempMap = new HashMap<>();
        strings.stream().peek(p -> tempMap.put(new Random().nextInt(), p)).forEach(System.out::print);
        System.out.println("將字符串集合轉爲Map集合，結果爲：" + tempMap);

        //======sorted()
        //元素已經實現comparable接口的排序
        List<Integer> sortedByNoArgs = numbers.parallelStream().sorted().collect(Collectors.toList());
        System.out.println("已經實現comparable接口的元素的排序：" + sortedByNoArgs);
        //自定義comparator來排序
        List<String> sortedByArgs = strings.parallelStream().sorted((p1, p2) -> {
            if (p1.length() != p2.length()) {
                return p1.length() - p2.length();
            } else {
                return p1.compareTo(p2);
            }
        }).collect(Collectors.toList());
        System.out.println("自定義比較器實現排序：" + sortedByArgs);

        //========findFirst() findAny() 取第一個值
        Integer findFirst = numbers.stream().findFirst().orElse(1); //返回第一個元素
        Integer findAny = numbers.stream().findAny().get(); //返回流中任意元素
        // 上面get()方法 IDEA提示"'Optional.get()' without 'isPresent()' check" 大概意思就是 有可能拿到空 將get()換成 orElse()給個默認值可解決
        System.out.println("流中第一個元素爲：" + findFirst + ",流中含有元素：" + findAny);

        //=======max() min() 取最大最小值
        Integer max = numbers.stream().max(Integer::compareTo).get();//獲取最大值
        Integer min = numbers.stream().min(Integer::compareTo).get(); //獲取最小值
        System.out.println("最大值爲：" + max + ",最小值爲：" + min);

        //=======allMatch() noneMatch() anyMatch()
        boolean allMatch = numbers.stream().allMatch(e -> e > 10); //false
        boolean noneMatch = numbers.stream().noneMatch(e -> e > 10); //false
        boolean anyMatch = numbers.stream().anyMatch(e -> e > 4);  //true
        System.out.println("集合中所有的元素都大於10：" + allMatch + ",集合中沒有一個元素大於10：" + noneMatch + ",集合中存在大於4的元素：" + anyMatch);

        //=======limit() 獲取n個元素
        List<Integer> limitList = numbers.parallelStream().limit(10).collect(Collectors.toList());
        System.out.println("獲取前10個元素爲："+limitList);

        //=======distinct() 根據元素的hashCode()和equals()去重
        List<Integer> distinctList = numbers.parallelStream().distinct().collect(Collectors.toList());
        System.out.println("去重後的集合爲："+distinctList);

        //=======skip() 跳過n個元素
        List<Integer> skipList = numbers.parallelStream().skip(3).collect(Collectors.toList());
        System.out.println("跳過前三個元素爲："+skipList);
    }

}

原字符串集合爲：[abc, , bc, efg, abcd, , jkl]
原數字集合爲：[0, 2, 2, 3, 7, 3, 5, 10, 24, 1, 22, 19]
===========================
去掉空字符串後的集合爲：[abc, bc, efg, abcd, jkl]
合併字符串元素：abc,bc,efg,abcd,jkl
合併字符串元素：abcbcefgabcdjkl
字符串集合中的空字符串個數爲：2
數字集合中每個元素+1，結果爲：[1, 3, 3, 4, 8, 4, 6, 11, 25, 2, 23, 20]
將字符串集合轉爲Map集合，結果爲：[{value=abc}, {value=}, {value=bc}, {value=efg}, {value=abcd}, {value=}, {value=jkl}]
abcbcefgabcdjkl將字符串集合轉爲Map集合，結果爲：{1857109122=jkl, 686121619=bc, 441563462=abc, -1182598392=efg, 1744894570=abcd, 666676726=, -1864601280=}
已經實現comparable接口的元素的排序：[0, 1, 2, 2, 3, 3, 5, 7, 10, 19, 22, 24]
自定義比較器實現排序：[, , bc, abc, efg, jkl, abcd]
流中第一個元素爲：0,流中含有元素：0
最大值爲：24,最小值爲：0
集合中所有的元素都大於10：false,集合中沒有一個元素大於10：false,集合中存在大於4的元素：true
獲取前10個元素爲：[0, 2, 2, 3, 7, 3, 5, 10, 24, 1]
去重後的集合爲：[0, 2, 3, 7, 5, 10, 24, 1, 22, 19]
跳過前三個元素爲：[3, 7, 3, 5, 10, 24, 1, 22, 19]

三、Ending

如果工作是爲了生活，那麼當你的生活全部變成了工作，你能堅持下去嗎？