詳解JAVA8Stream API {全}

Stream API 借助於同樣新出現的 Lambda 表達式，極大的提高編程效率和程序可讀性。同時它提供串行和並行兩種模式進行匯聚操作，並發模式能夠充分利用多核處理器的優勢，使用 fork/join 並行方式來拆分任務和加速處理過程。通常編寫並行代碼很難而且容易出錯, 但使用 Stream API 無需編寫一行多線程的代碼，就可以很方便地寫出高性能的並發程序

1.2 與傳統迭代器的區分

傳統迭代器是單向處理,數據按照一個方向流動,當然LisT的Iterator 提供了加強版本:

Stream 可以並行化操作，迭代器只能命令式地、串行化操作

原理實現:Stream 的並行操作依賴於 Java7 中引入的 Fork/Join 框架（JSR166y）來拆分任務和加速處理過程。Java 的並行 API 演變歷程基本如下：

1.0-1.4 中的 java.lang.Thread
5.0 中的 java.util.concurrent
6.0 中的 Phasers 等
7.0 中的 Fork/Join 框架
8.0 中的 Lambda

1.3 流的操作類型分為兩種：

Intermediate(中間操作不觸發操作 Lambda延遲性)：一個流可以后面跟隨零個或多個 intermediate 操作。其目的主要是打開流，做出某種程度的數據映射 / 過濾，然后返回一個新的流，交給下一個操作使用。這類操作都是惰性化的（lazy），就是說，僅僅調用到這類方法，並沒有真正開始流的遍歷。

Terminal(終止操作觸發整個流的操作)：一個流只能有一個 terminal 操作，當這個操作執行后，流就被使用 “光” 了，無法再被操作。所以這必定是流的最后一個操作。Terminal 操作的執行，才會真正開始流的遍歷，並且會生成一個結果，或者一個 side effect。

還有一種操作被稱為 short-circuiting。用以指：

對於一個 intermediate 操作，如果它接受的是一個無限大（infinite/unbounded）的 Stream，但返回一個有限的新 Stream。

對於一個 terminal 操作，如果它接受的是一個無限大的 Stream，但能在有限的時間計算出結果。

划重點:

Stream 的每個元素進行轉換，而且是執行多次，多個轉換操作只會在 Terminal 操作的時候融合起來，一次循環完成. 這樣時間復雜度就是 N（N為操作的具體的個數)

2:流的構造與轉換

2:1 常見構造

// 1. Individual values
Stream stream = Stream.of("a", "b", "c");
// 2. Arrays
String [] strArray = new String[] {"a", "b", "c"};
stream = Stream.of(strArray);
stream = Arrays.stream(strArray);
// 3. Collections
List<String> list = Arrays.asList(strArray);
stream = list.stream();

2.2: 三大包裝類型的構造

可以使用 Stream<Integer> Stream<Double> Stream<Long> 但是 Boxing unboxing (裝箱拆箱非常耗時)

IntStream ints = IntStream.of(1,2,3);
LongStream longs = LongStream.of(4,5,6);
DoubleStream doubles = DoubleStream.of(6,7,8);

IntStream.range(1, 10).forEach(System.out::print);// [1,10) 區間
System.out.println();
IntStream.rangeClosed(1, 10).forEach(System.out::print);//[1,10] 區間

2.3 並行流的規則輸出

parallel() 方法將普通流轉換為並行流

 IntStream.range(1, 10).parallel().forEach(System.out::print); // 並行執行 效率高 但是輸出結果不具備輸入結果的有序性
 IntStream.range(1, 10).parallel().forEachOrdered(System.out::print);// 並行執行 效率高  嚴格要求輸出結果按照輸入結果預定

2.4 流的轉換

collect() 方法

// 1. Array
String[] strArray1 = stream.toArray(String[]::new);
// 2. Collection
List<String> list1 = stream.collect(Collectors.toList());
List<String> list2 = stream.collect(Collectors.toCollection(ArrayList::new));
Set set1 = stream.collect(Collectors.toSet());
Stack stack1 = stream.collect(Collectors.toCollection(Stack::new));
// 3. String
String str = stream.collect(Collectors.joining()).toString();

注意: 一個Stream只能使用一次,terminal終結最后的操作

3:流操作

3.1 操作分類

Intermediate =>返回新的Stream

Filter Map(FatMap,MapToXXmap) Sorted() limit() skip distinct peek sequential、 unordered

Terminal => 終結操作

ForEach ForOrderEach Max Min Collect count toArray、 reduce、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator

shorting-circuing ==> 即可終結操作也可以返回新的Stream

findFisrt findAny AnyMatch AllMatch NoneMatch limit

3.2 Map 映射

參數為Function<T,R> 可以理解為轉換流

// 一對一
        IntStream.of(1,2,3).map(x->x*2).forEach(System.out::println);
        // 合並流
        Stream<List<Integer>> inputStream = Stream.of(
                Arrays.asList(1),
                Arrays.asList(2,3),
                Arrays.asList(4,5,6));
        Stream<Integer> child_stream = inputStream.flatMap(x->x.stream());
        // 合並流到其他類型 一對多
        DoubleStream doubleStream = inputStream.flatMapToDouble(x->x.stream().mapToDouble(Double::new));
        IntStream intStream = inputStream.flatMapToInt(x->x.stream().mapToInt(Integer::new));
        LongStream longStream = inputStream.flatMapToLong(x->x.stream().mapToLong(Long::new));
       // 轉大小寫
       List<String> output = wordList.stream().map(String::toUpperCase)
                                              .collect(Collectors.toList());
       // 平方數
       List<Integer> nums = Arrays.asList(1, 2, 3, 4);
        List<Integer> squareNums = nums.stream().
        map(n -> n * n).
        collect(Collectors.toList());

3.3 Filter 過濾器

參數為Predicate 結果集為返回true的集合

//留下偶數
        IntStream.range(1, 10).filter(x->(x&1)==0).forEach(System.out::println);
        
        Integer[] sixNums = {1, 2, 3, 4, 5, 6};
        Integer[] array = Stream.of(sixNums).filter(x->(x&1)==0).toArray(Integer[]::new);
       //  把單詞挑出來
       List<String> output = reader.lines().
         flatMap(line -> Stream.of(line.split(REGEXP))).
         filter(word -> word.length() > 0).
         collect(Collectors.toList());

3.4 Foreach Peek(Intermediate) 輸出

終結操作用於輸出 ,一個流只能用一次

forEachOrdered 在並行情況為保證一定有序輸出. Peek 內部參數 Consumer 執行操作后返回一個新的Stream

 Stream<List<Integer>> stream = Stream.of(Arrays.asList(1,2,3,4,5,6));
        
        stream.parallel().forEach(System.out::println);
        stream.parallel().forEachOrdered(System.out::println); //並行 強制有序
       // 體現了 訪問者設計模式
        Stream.of("one", "two", "three", "four")
            .filter(e -> e.length() > 3)
            .peek(e -> System.out.println("Filtered value: " + e))
            .map(String::toUpperCase)
            .peek(e -> System.out.println("Mapped value: " + e))
            .collect(Collectors.toList());
// 輸出 
Filtered value: three
Mapped value: THREE
Filtered value: four
Mapped value: FOUR

3.5 finalFist findAny

返回Optional 非終結操作,可以結果繼續處理使用它的目的是盡可能避免 NullPointerException。 indAny、max/min、reduce 等方法等返回 Optional 值

Integer[] sixNums = {1, 2, 3, 4, 5, 6};
            Stream.of(sixNums).findFirst().ifPresent(System.out::println);
            
            Stream.of(sixNums).findAny().ifPresent(System.out::println);
            // 返回的Optional 可以加上邏輯排除NPE
            Integer else1 = Stream.of(sixNums).filter(x->x<0).findAny().orElse(null);
            System.out.println(else1);
           // findFisrt  findAny 找不到元素拋出NPE 可以加上Or系列方法 返回默認值

3.6 Reduce

這個方法的主要作用是把 identity 作為第二個參數BinaryOperator 函數的輸入,執行操作后返回

T reduce(T identity, BinaryOperator<T> accumulator);

規則:

只有一個參數的時候BinaryOperator 返回Optional

具有兩個參數的時候則返回一個具體的運算結果

// 字符串連接，concat = "ABCD"
String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat); 
// 求最小值，minValue = -3.0
double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0).reduce(Double.MAX_VALUE, Double::min); 
// 求和，sumValue = 10, 有起始值
int sumValue = Stream.of(1, 2, 3, 4).reduce(0, Integer::sum);
// 求和，sumValue = 10, 無起始值
sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();
// 過濾，字符串連接，concat = "ace"
concat = Stream.of("a", "B", "c", "D", "e", "F").
 filter(x -> x.compareTo("Z") > 0).
 reduce("", String::concat);

以上字符串拼接、數值的 sum、min、max、average 都是特殊的 reduce

3.7 limit/skip

limit 返回 Stream 的前面 n 個元素；skip 則是扔掉前 n 個元素

public void testLimitAndSkip() {
        List<Person> persons = new ArrayList();
        for (int i = 1; i <= 10000; i++) {
            Person person = new Person(i, "name" + i);
            persons.add(person);
        }
        List<String> personList2 = persons.stream().map(Person::getName).limit(10).skip(3).collect(Collectors.toList());
        System.out.println(personList2);
    }
    private class Person {
        //get set
    }

注意:

limit/skip ,放在Sorted()后面並不能影響排序的次數

有一種情況是 limit/skip 無法達到 short-circuiting 目的的，就是把它們放在 Stream 的排序操作后，原因跟 sorted 這個 intermediate 操作有關：此時系統並不知道 Stream 排序后的次序如何，所以 sorted 中的操作看上去就像完全沒有被 limit 或者 skip 一樣

並行流情況下不能使用Limit() 將會影響並行操作的次序性能

對一個 parallel 的 Steam 管道來說，如果其元素是有序的，那么 limit 操作的成本會比較大，因為它的返回對象必須是前 n 個也有一樣次序的元素。取而代之的策略是取消元素間的次序，或者不要用 parallel Stream

3.8 排序 Sorted

List<Person> persons = new ArrayList();
 for (int i = 1; i <= 5; i++) {
 Person person = new Person(i, "name" + i);
 persons.add(person);
 }
List<Person> personList2 = persons.stream().limit(2).sorted((p1, p2) -> p1.getName().compareTo(p2.getName())).collect(Collectors.toList());
System.out.println(personList2);

3.9min/max/distinct

用 findFirst 來實現，但前者的性能會更好，為 O(n)，而 sorted 的成本是 O(n log n)。同時它們作為特殊的 reduce 方法被獨立出來也是因為求最大最小值是很常見的操作

Stream<Integer> stream = Stream.generate(()->new Random().nextInt()).limit(100);
        
        long nums = 100-stream.distinct().count();
        System.out.println(nums);
        Integer max = stream.max(Comparator.naturalOrder()).get();
        Integer min = stream.min(Comparator.naturalOrder()).get();

3.10 Match

Stream 有三個 match 方法，從語義上說：

allMatch：Stream 中全部元素符合傳入的 predicate，返回 true

anyMatch：Stream 中只要有一個元素符合傳入的 predicate，返回 true

noneMatch：Stream 中沒有一個元素符合傳入的 predicate，返回 true

List<Person> persons = new ArrayList();
persons.add(new Person(1, "name" + 1, 10));
persons.add(new Person(2, "name" + 2, 21));
persons.add(new Person(3, "name" + 3, 34));
persons.add(new Person(4, "name" + 4, 6));
persons.add(new Person(5, "name" + 5, 55));
boolean isAllAdult = persons.stream().
 allMatch(p -> p.getAge() > 18);
System.out.println("All are adult? " + isAllAdult);
boolean isThereAnyChild = persons.stream().
 anyMatch(p -> p.getAge() < 12);
System.out.println("Any child? " + isThereAnyChild);

4生成流

4.1 generate

Supplier 接口，你可以自己來控制流的生成。這種情形通常用於隨機數、常量的 Stream，或者需要前后元素間維持着某種狀態信息的 Stream.

generate 內部維護一個無限制的循環根據傳入的規則生成數據

需要使用Limit限制數據生成的范圍

Random seed = new Random();
Supplier<Integer> random = seed::nextInt;
Stream.generate(random).limit(10).forEach(System.out::println);
//Another way
IntStream.generate(() -> (int) (System.nanoTime() % 10000)).
limit(10).forEach(System.out::println);

自定義Supplier

Stream<Person> stream2 = Stream.generate(new Use_Max_Min_Distinct().new PersonSupplier()).limit(10);
        stream2.forEach(System.out::println);
  
  private class PersonSupplier implements Supplier<Person>{
        private Random random=new Random();
        @Override
        public Person get() {
            return new Person("Tom",random.nextInt());
        }
    }
    private class Person{
        private String name;
        // Constructor get set toString()
    }

4.2 Iterator

iterate 跟 reduce 操作很像，接受一個種子值，和一個 UnaryOperator（例如 f）。

然后種子值成為 Stream 的第一個元素，f(seed) 為第二個，f(f(seed)) 第三個，以此類推。

Stream.iterate(0, n -> n + 3).limit(10). forEach(x -> System.out.print(x + " "));
// 0 3 6 9 12 15 18 21 24 27

在 iterate 時候管道必須有 limit 這樣的操作來限制 Stream 大小。

5.聚合操作

5.1 groupingBy/partitioningBy

groupingBy 參數Function 多值的聚合操作
partitioningBy 參數Predicate true false 的單值操作

 List<Person> list = Arrays.asList(
                    new Person("Tom1", 1),
                    new Person("Tom2", 2),
                    new Person("Tom3", 3),
                    new Person("Tom4", 2),
                    new Person("Tom5", 3),
                    new Person("Tom6", 2)
                    );
            // 分類
            Map<Integer, List<Person>> personGroups = 
                    Stream.generate(new PersonSupplier()).limit(10)
                    .collect(Collectors.groupingBy(Person::getAge));
            Stream<Entry<Integer, List<Person>>> stream = personGroups.entrySet().stream();
            List<Entry<Integer, List<Person>>> list2 = stream.collect(Collectors.toList());
            Iterator<Entry<Integer, List<Person>>> iterator = list2.iterator();
            while(iterator.hasNext()) {
                Entry<Integer, List<Person>> entry = iterator.next();
                System.out.println(entry.getKey()+" "+entry.getValue());
            }
            // 按照斷言划分
            Map<Boolean, List<Person>> map = Stream.generate(new PersonSupplier()).limit(10)
            .collect(Collectors.partitioningBy(x->x.getAge()>5));
            Stream<Entry<Boolean, List<Person>>> stream2 = map.entrySet().stream();
            stream2.forEach((entry)->System.out.println(entry.getKey()+" "+entry.getValue()));
   class PersonSupplier implements Supplier<Person>{
    public Person get() {
        return new Person("Tom"+new Random().nextInt(10) , new Random().nextInt(10));
    };
}
class Person {}// Constructor get set ToString()

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 詳解JAVA8Stream 方法引用(基礎){全} 流式計算（一）-Java8Stream Java8stream表達式 java8Stream多線程並行數據處理 Java8學習筆記（五）--Stream API詳解[轉] Java8 Stream API java8 Stream API之reduce java8新特性——Stream API Java 8 Stream Api 中的 peek 操作 Java集合框架詳解（全）