Java Stream從精通到陌生

1.Stream是什麼，爲什麼用它

Stream 是數據渠道，用於操作數據源生成的元素序列，集合講的是數據，流講的是計算，就像糧食加工廠一樣 糧食就是集合，加工廠就是Stream，對糧食進行一系列的操作。
用來以 做什麼而非怎麼做 的方式來處理集合
舉一個梨子
現在有一個集合

  List<String> strings = Arrays.asList("王1福", "王2福", "王3福", "小王8");

裏面混入了一個奇怪的小王8，我想知道里面除了小王8的個數
以前的我

        int count = 0;
        for (String string : strings) {
            if (!string.equals("小王8")) {
                count++;
            }

        }
        System.out.println(count);

會了Stream的我

        long count = strings.stream().filter((x) -> !x.equals("小王8")).count();
        System.out.println(count);

有人肯定會說笨b你都說混入一個奇怪的小王8了你直接獲取個數減1不就行了！
我：？？？？
那我現在要給他們排序然後輸出
以前的我

        Collections.sort(strings);
        for (String string : strings) {
            System.out.println(string);
        }

會了Stream的我

 strings.stream().sorted(String::compareTo).forEach(System.out::println);

有人肯定會說這不差不多嗎？感覺沒啥區別啊

那我現在要 取前3個，跳過第一個，然後排序，然後遍歷輸出
以前的我

不想寫

會了Stream的我

strings.stream().limit(3).skip(1).sorted(String::compareTo).forEach(System.out::println);

這時候又有人說了：你說了這麼多，我不想學啊

2.Stream怎麼用

首先你需要了解Lambda表達式 請看這裏Lambda入門
Stream 有三個階段 1.創建流 2.中間操作，可多步驟 3.終止操作，從而產生結果

流表面上和集合很相似，都可以讓我們，轉換和獲取數據，但是他們中間存在很明顯的差異
1.流不存儲元素。
2.流的操作不好修改數據源，在我一開始的例子中Collections.sort就修改了數據源
3.流的操作都是惰性的

2.1創建流

1.集合創建流
Collection接口的stream

   List<String> strings = Arrays.asList("王1福", "王2福", "王3福", "小王8"); 
   Stream<String> stream = strings.stream();

2.數組創建流
Arrays.stream()

        String [] strings1={"王1福", "王2福", "王3福", "小王8"};
        Stream<String> stream1 = Arrays.stream(strings1);

3.直接創建

   public static<T> Stream<T> of(T... values) {
        return Arrays.stream(values);
    }
   Stream<Object> empty = Stream.empty();
   Stream<Integer> integerStream = Stream.of(1, 2, 3);
  Stream<Integer> iterate = Stream.iterate(0, (x) -> ++x);

2.2中間操作

2.2.1篩選與切片

    filter：過濾流中的某些元素
    limit(n)：獲取n個元素
    skip(n)：跳過n元素，配合limit(n)可實現分頁
    distinct：通過流中元素的 hashCode() 和 equals() 去除重複元素

2.2.2映射

    map：將元素轉換成其他形式或提取信息，將其映射成新的元素，將流添加進流中  與list的add

        List<String> strings = Arrays.asList("a", "b", "c", "d");
        Stream<String> stream = strings.stream();
        stream.map(String::toUpperCase).forEach(System.out::print);//ABCD

map 是的結果是包含了應用該函數後所以產生的所有結果的流，如果它返回的不是一個值而是一個流

    @Test
    public void one() {
        //List<String> strings = Arrays.asList("王1福", "王2福", "王3福", "小王8");
        List<String> strings = Arrays.asList("aaa", "bbbb", "cbbb", "dbbb");
        Stream<String> stream = strings.stream();
        Stream<Stream<String>> streamStream = stream.map(this::letters);
        streamStream.forEach((x) -> {
            x.forEach(System.out::print);
            System.out.println();
        });
    }


    Stream<String> letters(String s) {
        ArrayList<String> result = new ArrayList<>();
        for (int i = 0; i < s.length(); i++) {
            result.add(s.substring(i, i + 1));
        }
        return result.stream();
    }

輸出

aaa
bbbb
cbbb
dbbb

    flatMap：接收一個函數作爲參數，將流中的每個值都換成另一個流，然後把所有流連接成一個流。

    @Test
    public void one() {
        //List<String> strings = Arrays.asList("王1福", "王2福", "王3福", "小王8");
        List<String> strings = Arrays.asList("aaa", "bbbb", "cbbb", "dbbb");
        Stream<String> stream = strings.stream();
  
        Stream<String> stringStream = stream.flatMap(this::letters);
        stringStream.forEach(System.out::print);//aaabbbbcbbbdbbb
    }

注意：一個流終止後就不能用了 否則會報IllegalStateException

//流已被操作或關閉
java.lang.IllegalStateException: stream has already been operated upon or closed

2.2.3排序

    sorted()：返回由此流的元素組成的流，根據自然順序排序
    sorted(Comparator com)：定製排序，根據提供的 Comparator進行排序。 

        List<String> strings = Arrays.asList("a", "d", "b", "c");
        //dcba
        strings.stream().sorted((a1, a2) -> a2.compareTo(a1)).forEach(System.out::print);

2.3結束操作

2.3.1 查找與匹配

    allMatch：是否匹配所有的元素
    noneMatch：一個匹配的元素都沒有
    anyMatch：至少匹配一個元素
    findFirst：返回流中第一個元素
    findAny：返回流中的任意元素
    count：返回流中元素的總個數
    max：返回流中元素最大值
    min：返回流中元素最小值

2.3.2 歸約

    reduce ：可以將流中元素反覆結合起來 得到一個值

        List<Integer> strings = Arrays.asList(1, 2, 3, 4);
        //起始值
        int loadVar=0;
        Integer reduce = strings.stream().reduce(loadVar, (x, y) -> x + y);

2.3.3 收集

    collect：收集然後將其轉換爲其他形式，用於彙總操作

常用的一些操作

        List<Integer> strings = Arrays.asList(1, 2, 3, 4);

        //總數 4
        Long collect = strings.stream().collect(Collectors.counting());
       

        //int相加 其他類型也有  10
        Integer collect1 = strings.stream().collect(Collectors.summingInt(x -> x));
      

        //轉成集合  [1, 2, 3, 4]
        List<Integer> toList = strings.stream().collect(Collectors.toList());
    
        //轉成map {1=1, 2=2, 3=3, 4=4}
        Map<Integer, Integer> collect3 = strings.stream().collect(Collectors.toMap((x) -> x, (x) -> x));
      

        //分組 {1=[1], 2=[2], 3=[3], 4=[4]}
        Map<Integer, List<Integer>> collect2 = strings.stream().collect(Collectors.groupingBy(x -> x));
        //分區  {false=[1, 2], true=[3, 4]}
        Map<Boolean, List<Integer>> collect4 = strings.stream().collect(Collectors.partitioningBy((x) -> x > 2));
      


        collect2.forEach((key, val) -> System.out.println(key + "--" + val));
     

2.4並行流

一個內容分成多個數據塊，並用多個線程分別處理每個數據塊
parallel 轉換爲 並行流
.sequential 轉化爲順序流

        Instant now = Instant.now();

        long reduce = LongStream.range(0, 1000000000).parallel().reduce(0, (x, y) -> x + y);
        Instant end = Instant.now();

        System.out.println("消耗時間"+ Duration.between(now,end).toMillis() +"值"+reduce);

並行流試用的場景
1.Stream.interate 返回的結果不行
2.數據量很大時，不然沒有意義
3.流的操作不應該阻塞
只有對已經存在內存中的數據執行大量計算時，才應該使用並行流

參考
https://www.bilibili.com/video/BV1gJ41137p2?p=21
Java核心技術卷二