雖然java 10已經發布，11 已經在路上，雖然 java EE 已經更名為 jakarta EE，但是大多數人連jdk1.8的新特性都不太瞭解，本人也是如此，所以在學習Java 8 API 新增的 Stream 的時候 做一些個人筆記，希望幫助自己的同時也能幫到大家。

首先對stream的操作可以分為兩類，中間操作(intermediate operations)和結束操作(terminal operations):

• 中間操作總是會惰式執行，呼叫中間操作只會生成一個標記了該操作的新stream。
• 結束操作會觸發實際計算，計算髮生時會把所有中間操作積攢的操作以pipeline的方式執行，這樣可以減少迭代次數。計算完成之後stream就會失效。

雖然大部分情況下stream是容器呼叫Collection.stream()方法得到的，但stream和collections有以下不同：

• 無儲存。stream不是一種資料結構，它只是某種資料來源的一個檢視，資料來源可以是一個數組，Java容器或I/O channel等。
• 為函數語言程式設計而生。對stream的任何修改都不會修改背後的資料來源，比如對stream執行過濾操作並不會刪除被過濾的元素，而是會產生一個不包含被過濾元素的新stream。
• 惰式執行。stream上的操作並不會立即執行，只有等到使用者真正需要結果的時候才會執行。
• 可消費性。stream只能被“消費”一次，一旦遍歷過就會失效，就像容器的迭代器那樣，想要再次遍歷必須重新生成。

一、獲取stream

    // 1、陣列
    String[] arr = new String[]{"ab", "cd", "ef"};
    Stream<String> arrStream = Arrays.stream(arr);
    // 2、集合
    List<String> list = Arrays.asList("ab", "cd", "ef");
    Stream<String> colStream = list.stream();
    // 3、值
    Stream<String> stream = Stream.of("ab", "cd", "ef");
 

二、stream方法使用

測試資料：

  List<User> list = Arrays.asList(
     // name，age
      new User("張三", 11),
      new User("王五", 20),
      new User("王五", 91),
      new User("張三", 8),
      new User("李四", 44),
      new User("李四", 44),
      new User("李四", 44)
  );

1、forEach() 使用該方法迭代流中的每個資料

  /**
   * forEach 迭代輸出每條資料.
   */
  @Test
  public void testForEach(){
    // java 8 前
    System.out.println("java 8 前");
    for(User user: list){
      System.out.println(user);
    }
    // java 8 lambda
    System.out.println("java 8 lambda");
    list.forEach(user -> System.out.println(user));

    // java 8 stream lambda
    System.out.println("java 8 stream lambda");
    list.stream().forEach(user -> System.out.println(user));
  }

console->

2、sorted() 使用該方法排序資料

  /**
   * sort 排序.
   */
  @Test
  public void testSort() {
    System.out.println("-----排序前-----");
    list.forEach(user -> System.out.println(user));
    System.out.println("-----排序後-----");
    // java 8 前
    System.out.println("java 8 前");
    Collections.sort(list, new Comparator<User>() {
      @Override
      public int compare(User o1, User o2) {
        return o1.getAge().compareTo(o2.getAge());
      }
    });
    for (User user : list) {
      System.out.println(user);
    }
    // java 8 stream 方法引用
    System.out.println("java 8 stream 方法引用");
    list.stream().sorted(Comparator.comparing(User::getAge)).forEach(user -> System.out.println(user));
  }

console->

3、filter()：使用該方法過濾

  /**
   * filter 過濾.
   */
  @Test
  public void testFilter() {
    // 輸出年齡大於50的人
    System.out.println("-----過濾前-----");
    list.forEach(user -> System.out.println(user));
    System.out.println("-----過濾後-----");
    // java 8 前
    System.out.println("java 8 前");
    for(User user: list){
      if (user.getAge() > 50) {
        System.out.println(user);
      }
    }
    // java 8 stream
    System.out.println("java 8 stream");
    list.stream().filter((User user) -> user.getAge() > 50).forEach(user -> System.out.println(user));
  }

console->

4、limit()：使用該方法截斷

  /**
   * limit 截斷.
   */
  @Test
  public void testLimit() {
    // 從第三個開始截斷，只輸出前三個
    System.out.println("-----截斷前-----");
    list.forEach(user -> System.out.println(user));
    System.out.println("-----截斷後-----");
    // java 8 前
    System.out.println("java 8 前");
    for (int i = 0; i < 3; i++) {
      System.out.println(list.get(i));
    }
    // java 8 stream
    System.out.println("java 8 stream");
    list.stream().limit(3).forEach(user -> System.out.println(user));
  }

console->

5、skip()：與limit互斥，使用該方法跳過元素

  /**
   * skip 跳過.
   */
  @Test
  public void testSkip() {
    // 跳過前三個元素，從第四個開始輸出
    System.out.println("-----跳過前-----");
    list.forEach(user -> System.out.println(user));
    System.out.println("-----跳過後-----");
    // java 8 前
    System.out.println("java 8 前");
    for (int i = 3; i < list.size(); i++) {
      System.out.println(list.get(i));
    }
    // java 8 stream
    System.out.println("java 8 stream");
    list.stream().skip(3).forEach(user -> System.out.println(user));
  }

console->

6、distinct()：使用該方法去重，注意：必須重寫對應泛型的hashCode()和equals()方法

  /**
   * distinct 去重.
   */
  @Test
  public void testDistinct() {
    // 因為Arrays.asList() 返回的是Arrays的內部類ArrayList，操作remove，add會報錯
    List<User> users = new ArrayList(list);
    // 為list去除重複資料
    System.out.println("-----去重前-----");
    list.forEach(user -> System.out.println(user));
    System.out.println("-----去重後-----");
    // java 8 前
    System.out.println("java 8 前");
    for (int i = 0; i < users.size() - 1; i++) {
      for (int j = users.size() - 1; j > i; j--) {
        if (users.get(j).getAge() == users.get(i).getAge() && users.get(j).getName()
            .equals(users.get(i).getName())) {
          users.remove(i);
        }
      }
    }
    for (User user : users) {
      System.out.println(user);
    }
    // java 8 stream
    System.out.println("java 8 stream");
    users.stream().distinct().forEach(user -> System.out.println(user));
  }

console->

***根據上述方法，完成去重+按照年齡大於40以後從小到大+只取前二

  /**
   * 去重+按照年齡大於40以後從小到大+只取前二
   */
  @Test
  public void demo() {
    list.stream().distinct().filter(user -> user.getAge() > 40).sorted(
        Comparator.comparing(User::getAge)).limit(2).forEach(user -> System.out
        .println(user));
  }

console->

7、max，min，sum，avg，count 

  /**
   * 測試計算.
   */
  @Test
  public void testNum() {
    IntSummaryStatistics num = list.stream().mapToInt(u -> u.getAge())
        .summaryStatistics();
    System.out.println("總共人數：" + num.getCount());
    System.out.println("平均年齡：" + num.getAverage());
    System.out.println("最大年齡：" + num.getMax());
    System.out.println("最小年齡：" + num.getMin());
    System.out.println("年齡之和：" + num.getSum());
  }

console->

8、map()：接收一個方法作為引數，該函式會被應用到每個元素上，並將其對映成一個新的元素

  /**
   * map 對映.
   */
  @Test
  public void testMap() {
    // 只輸出所有人的年齡
    list.stream().forEach(user -> System.out.println(user));
    System.out.println("對映後----->");
    List<Integer> ages = list.stream().map(user -> user.getAge()).collect(toList());
    ages.forEach(age -> System.out.println(age));

    // 小寫轉大寫
    List<String> words = Arrays.asList("aaa", "vvvv", "cccc");
    System.out.println("全部大寫---->");
    List<String> collect = words.stream().map(s -> s.toUpperCase()).collect(toList());
    collect.forEach(s -> System.out.println(s));
  }

console->

9、flatMap()：對每個元素執行mapper指定的操作，並用所有mapper返回的Stream中的元素組成一個新的Stream作為最終返回結果，通俗易懂就是將原來的stream中的所有元素都展開組成一個新的stream

 /**
   * flatMap .
   */
  @Test
  public void testFlatMap() {
    //建立一個 裝有兩個泛型為integer的集合
    Stream<List<Integer>> stream = Stream.of(Arrays.asList(1, 2, 3), Arrays.asList(4, 5));
    // 將兩個合為一個
    Stream<Integer> integerStream = stream.flatMap(
        (Function<List<Integer>, Stream<Integer>>) integers -> integers.stream());
    // 為新的集合
    List<Integer> collect = integerStream.collect(toList());
    System.out.println("新stream大小:"+collect.size());
    System.out.println("-----合併後-----");
    collect.forEach(o -> System.out.println(o));
  }

console->

10、findFirst() ：使用該方法獲取第一個元素

  /**
   * findFirst 獲取第一個元素.
   */
  @Test
  public void testFindFirst(){
    User user = list.stream().findFirst().get();
    System.out.println(user);
  }

console->