（1）、創建Stream ：一個數據源（如：集合、數組），獲取一個流

（2）、中間操作： 一個中間操作鏈，對數據源的數據進行處理

（3）、終止操作（終端操作）： 一個終止操作，執行中間操作鏈，并產生結果

1、生成流

// 由Collection創建流
List<String> list = new ArrayList<>();
Stream<String> stream1 = list.stream();
// 由數組創建流
Employee[] emps = new Employee[10];
Stream<Employee> stream2 = Arrays.stream(emps);

2、中間操作

• filter--接收 Lambda，從流中排除某些元素

  private static List<User> initList() {
          List<User> userList = new ArrayList<>();
          userList.add(new User("1", "xiaom", 18, 3500, "0"));
          userList.add(new User("2", "shany", 20, 13500, "0"));
          userList.add(new User("3", "damao", 35, 7000, "0"));
          userList.add(new User("4", "guoer", 17, 6500, "1"));
          userList.add(new User("5", "longn", 18, 4500, "0"));
          userList.add(new User("6", "guoer", 25, 9200, "1"));
          return userList;
  }
  
  List<User> userList = initList();
          
  userList.stream()
           .filter((e) -> e.getAge() > 18)
           .forEach(System.out::println);
  // 結果
  User{id='2', name='shany', age=20, status=0}
  User{id='3', name='damao', age=35, status=0}
  User{id='6', name='guoer', age=25, status=1}

• limit--截斷流，使其元素不超過給定數量
  

  userList.stream()
            .filter((e) -> e.getAge() > 18)
            .limit(2)
            .forEach(System.out::println);
  // 結果
  User{id='2', name='shanyu', age=20, status=0}
  User{id='3', name='damao', age=35, status=0}

• skip(n)--跳過元素，返回一個扔掉了前n個元素的流
  

  userList.stream()
            .filter((e) -> e.getAge() > 18)
            .skip(1)
            .limit(1)
            .forEach(System.out::println);
  // 結果
  User{id='3', name='damao', age=35, status=0}

• distinct--篩選，通過流所生成元素的 hashCode() 和 equals() 去除重復元素
  

  userList.stream()
            .distinct()
            .forEach(System.out::println);
  // 結果，去重name=guoer
  User{id='1', name='xiaoming', age=18, status=0}
  User{id='2', name='shanyu', age=20, status=0}
  User{id='3', name='damao', age=35, status=0}
  User{id='4', name='guoer', age=17, status=1}
  User{id='5', name='longnv', age=18, status=0}

• map--接收Lambda，將元素轉換成其他形式或提取信息。接收一個函數作為參數，該函數會被應用到每個元素上，返回新元素。
  

  userList.stream()
            .map(User::getName)
            .forEach(System.out::println);
  //結果
  XIAOMING SHANYU DAMAO GUOER LONGNV GUOER

• peek--返回由該流的元素組成的流，并對每個元素執行所提供的Consumer操作方法。
  

  userList.stream()
            .peek(e -> e.setName(e.getName().toUpperCase()))
            .forEach(System.out::println);
  // 結果
  User{id='1', name='XIAOMING', age=18, status=0}
  User{id='2', name='SHANYU', age=20, status=0}
  User{id='3', name='DAMAO', age=35, status=0}
  User{id='4', name='GUOER', age=17, status=1}
  User{id='5', name='LONGNV', age=18, status=0}
  User{id='6', name='GUOER', age=25, status=1}

• sorted(Comparator com)----定制排序（Comparator）
  

  List<String> list = Arrays.asList("ccc", "aaa", "bbb", "ddd", "eee");
          list.stream()
                  .sorted()
                  .forEach(System.out::println);
  
          System.out.println("=======定制排序=========");
  
          List<User> userList = initList();
          userList.stream()
                  .sorted((x, y) -> {
                      if (x.getAge() == y.getAge()) {
                          return x.getName().compareTo(y.getName());
                      } else {
                          return Integer.compare(x.getAge(), y.getAge());
                      }
                  }).forEach(System.out::println);
  // 結果
  aaa
  bbb
  ccc
  ddd
  eee
  =======定制排序=========
  User{id='4', name='guoer', age=17, status=1}
  User{id='5', name='longnv', age=18, status=0}
  User{id='1', name='xiaoming', age=18, status=0}
  User{id='2', name='shanyu', age=20, status=0}
  User{id='6', name='guoer', age=25, status=1}
  User{id='3', name='damao', age=35, status=0}

3、終止操作

• allMatch——檢查是否匹配所有元素
• anyMatch——檢查是否至少匹配一個元素
• noneMatch——檢查是否沒有匹配的元素
• findFirst——返回第一個元素
• findAny——返回當前流中的任意元素
• count——返回流中元素的總個數
• max——返回流中最大值
• min——返回流中最小值
• reduce(T identity, BinaryOperator) / reduce(BinaryOperator) ——可以將流中元素反復結合起來，得到一個值。
• Collector接口中方法的實現決定了如何對流執行收集操作（如收集到List、Set、Map）。但是Collectors實用類提供了很多靜態方法，可以方便地創建常見收集器實例，具體方法與實例如下表
  
  

  方法	返回類型	作用
  toList	List<T>	把流中元素收集到List
  toSet	Set<T>	把流中元素收集到Set
  toCollection	Conllection<T>	把流中元素收集到創建的集合
  counting	Long	計算流元素中的個數
  summingInt	Integer	對流中元素的整數屬性求和
  avargingInt	Double	計算流中元素Integer屬性的平均值
  summarizingInt	IntSummaryStatistics	收集流中Integer屬性的統計值,如平均值
  joining	String	連接流中的每個字符串
  maxBy	Optional<T>	根據比較器選擇最大值
  minBy	Optional<T>	根據比較器選擇最小值
  reducing	歸約產生的類型	從一個作為累加器的初始值開始，利用BinaryOperator與流中元素逐個結合，從而歸約成單個值
  collectingAndThen	轉換函數返回的類型	包裹另一個收集器，對其結果轉換函數
  groupingBy	Map<K, List<T>>	根據某屬性值對流分組，屬性為K，結果為V
  partitioningBy	Map<Boolean, List<T>>	根據true或者false進行分區