博文内容和示例以及圖檔均參考自：https://zhuanlan.zhihu.com/p/285237824?utm_source=wechat_session&utm_medium=social&utm_oi=1087860225041776640&utm_campaign=shareopn
在此表示感謝，如有侵權，請聯系删除！！
Stream 概述
Java 8 版本是一個非常成功的版本，此版本中新增的 Stream 和 Lambda，為我們平時對集合（Collection）的操作提供了非常大的便利。Stream是将要處理的元素集合看成一種流，在流的過程中，借助 Stream API 提供的方法對流中的元素進行相應的操作，這些操作包括但不限于如篩選、排序、聚合等。
Stream 的幾個特性：
- stream 不存儲資料，而是按照特定的規則對資料進行計算，一般會輸出結果；
- stream 不會改變資料源，通常情況下會産生一個新的集合或一個值；
- stream 具有延遲執行的特性，隻有調用終端操作時，中間操作才會執行
Stream 的建立
stream 可以通過集合數組去建立
通過 java.util.Collection.stream() 方法用集合建立流
List<String> listStr = Arrays.asList("a","b","c","d");
//建立一個順序流
Stream<String> stream = listStr.stream();
//建立一個并行流
Stream<String> parallelStream = listStr.parallelStream();
使用 java.util.Arrays.stream(T[] array) 方法用數組建立流
int arr[] = {1,2,3,4,5};
IntStream stream = Arrays.stream(arr);
使用 Stream 的靜态方法 of()、iterate()、generate() 建立 stream
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
System.out.println("輸出 stream 為：");
stream.forEach(System.out::println);
Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 3).limit(4);
System.out.println("輸出 stream2 為：");
stream2.forEach(System.out::println);
Stream<Double> stream3 = Stream.generate(Math::random).limit(3);
System.out.println("輸出 stream3 為：");
stream3.forEach(System.out::println);
stream（順序流）和 parallelStream（并行流）的差別在于：stream 是順序流，由主線程按順序對流執行相應操作，而 parallelStream 是并行流，内部以多線程并行執行的方式對流進行操作，但前提是流中的資料對于處理沒有順序要求。以篩選集合中的奇數為例，來說明順序流與并行流的差別：
如果流中的資料量足夠大，那麼并行流的處理效果是非常明顯的。
Stream 使用之周遊與比對（foreach、find、match）
stream 是支援類似集合的周遊和比對元素的，隻是 stream 中的元素是以 Optional 類型存在的。Optional 類是一個可以為 null 的容器對象，如果值存在則 isPresent() 方法會傳回 true，調用 get() 方法會傳回該對象。
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
public class StreamTest {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(7, 6, 9, 3, 8, 2, 1);
// 周遊輸出大于6的元素
list.stream().filter(x -> x > 6).forEach(System.out::println);
// 比對第一個大于7的元素
Optional<Integer> findFirst = list.stream().filter(x -> x > 7).findFirst();
// 比對任意（适用于并行流）大于3的元素
Optional<Integer> findAny = list.parallelStream().filter(x -> x > 3).findAny();
// 是否包含符合特定條件（小于6）的元素
boolean anyMatch = list.stream().anyMatch(x -> x < 6);
System.out.println("比對第一個值：" + findFirst.get());
System.out.println("比對任意一個值：" + findAny.get());
System.out.println("是否存在小于6的值：" + anyMatch);
}
}
Stream 使用之篩選（filter）
篩選，簡單來講就是按照一定的規則校驗流中的元素，将符合條件的元素提取到新的流中的操作。
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
public class StreamTest {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(6, 7, 3, 8, 1, 2, 9);
Stream<Integer> stream = list.stream();
System.out.println("大于7的元素有：");
stream.filter(x -> x > 7).forEach(System.out::println);
}
}
Stream 使用之聚合（max、min、count）
在 MySQL 中，我們經常使用 max、min 和 count 來進行資料統計。在 Java Stream 中也引入了這些概念和用法，為我們對集合、數組的資料統計工作提供了極大的便利。
例：擷取 String 類型的集合中長度最長的元素
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
public class StreamTest {
public static void main(String[] args) {
List<String> list = Arrays.asList("abcd", "ads", "admin", "Java", "Java Stream");
System.out.println("list = " + list);
Optional<String> max = list.stream().max(Comparator.comparing(String::length));
System.out.println("其中最長的元素是：" + max.get());
}
}
例：擷取 Integer 類型的集合中的最大值
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.Optional;
public class StreamTest {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(7, 6, 9, 4, 11, 6);
// 自然排序
Optional<Integer> max = list.stream().max(Integer::compareTo);
// 自定義排序
Optional<Integer> max2 = list.stream().max(new Comparator<Integer>() {
@Override
public int compare(Integer a, Integer b) {
return a.compareTo(b);
}
});
System.out.println("自然排序的最大值：" + max.get());
System.out.println("自定義排序的最大值：" + max2.get());
}
}
例：擷取集合中符合某特定條件的元素個數
import java.util.Arrays;
import java.util.List;
public class StreamTest {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(7, 6, 4, 8, 2, 11, 9);
System.out.println("list = " + list);
long count = list.stream().filter(x -> x > 6).count();
System.out.println("list中大于6的元素個數：" + count);
}
}
Stream 使用之映射（map/flatMap）
映射，即是可以将一個流的元素按照一定的映射規則映射到另一個流中，分為 map 和 flatMap：
- map：接收一個函數作為參數，該函數會被應用到每個元素上，并将其映射成一個新的元素；
- flatMap：接收一個函數作為參數，将流中的每個值都換成另一個流，然後把所有流連接配接成一個流
例：将英文字元串數組的元素全部改為大寫，整數數組每個元素 + 3
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class StreamTest {
public static void main(String[] args) {
// String 數組
String[] strArr = { "abcd", "asd", "xyzz", "java" };
List<String> strList = Arrays.stream(strArr).map(String::toUpperCase).collect(Collectors.toList());
// 整數數組
List<Integer> intList = Arrays.asList(1, 3, 5, 7, 9, 11);
List<Integer> intListNew = intList.stream().map(x -> x + 3).collect(Collectors.toList());
System.out.println("轉換為大寫之後的String數組：" + strList);
System.out.println("每個元素 +3 之後的整數數組：" + intListNew);
}
}
例：将兩個字元數組合并成一個新的字元數組：
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class StreamTest {
public static void main(String[] args) {
List<String> list = Arrays.asList("m,k,l,a", "1,3,5,7");
List<String> listNew = list.stream().flatMap(s -> {
// 将每個元素轉換成一個stream
String[] split = s.split(",");
Stream<String> s2 = Arrays.stream(split);
return s2;
}).collect(Collectors.toList());
System.out.println("合并前：" + list);
System.out.println("合并後：" + listNew);
}
}
Stream 使用之歸約（reduce）
所謂歸約，也稱縮減，即是把一個流縮減成一個值，能實作對集合求和、求乘積和求最值的操作。
例：求整數集合中的各個元素的和、乘積和最大值
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
public class StreamTest {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(1, 3, 2, 8, 11, 4);
// 求和方式1
Optional<Integer> sum = list.stream().reduce((x, y) -> x + y);
// 求和方式2
Optional<Integer> sum2 = list.stream().reduce(Integer::sum);
// 求和方式3
Integer sum3 = list.stream().reduce(0, Integer::sum);
// 求乘積
Optional<Integer> product = list.stream().reduce((x, y) -> x * y);
// 求最大值方式1
Optional<Integer> max = list.stream().reduce((x, y) -> x > y ? x : y);
// 求最大值寫法2
Integer max2 = list.stream().reduce(1, Integer::max);
System.out.println("sum = " + sum.get() + "," + sum2.get() + "," + sum3);
System.out.println("mul = " + product.get());
System.out.println("max = " + max.get() + "," + max2);
}
}
Stream 使用之收集（collect）
collect，意為收集。關于 collect，可以說是内容最多、功能最豐富的部分了。收集，即是把一個流收集起來，最終可以是收內建一個值也可以收內建一個新的集合。使用一個新的例子來說明 collect 的使用。
public class Person {
private String name; // 姓名
private int salary; // 薪資
private int age; // 年齡
private String sex; //性别
private String area; // 地區
// 構造方法
public Person(String name, int salary, int age,String sex,String area) {
this.name = name;
this.salary = salary;
this.age = age;
this.sex = sex;
this.area = area;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getArea() {
return area;
}
public void setArea(String area) {
this.area = area;
}
}
歸集（toList/toSet/toMap）
因為流不存儲資料，那麼在流中的資料完成處理後，需要将流中的資料重新歸集到新的集合裡，最常用的是 toList、toSet、toMap。
package demo;
import java.util.*;
import java.util.stream.Collectors;
public class StreamTest {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(1, 6, 3, 4, 6, 7, 9, 6, 20);
// 輸出 list 中的偶數
List<Integer> listNew = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());
// 輸出 list 中的偶數，不重複
Set<Integer> set = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toSet());
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
personList.add(new Person("Anni", 8200, 24, "female", "New York"));
personList.add(new Person("Owen", 9500, 25, "male", "New York"));
personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
// 将員工中工資 > 8000 的員工姓名輸出
Map<?, Person> map = personList.stream().filter(p -> p.getSalary() > 8000)
.collect(Collectors.toMap(Person::getName, p -> p));
System.out.println("toList:" + listNew);
System.out.println("toSet:" + set);
System.out.println("toMap:" + map);
}
}
統計（count/averaging）
Collectors 提供了一系列用于資料統計的靜态方法：如，計數、平均值、最值、求和、統計等。例：統計員勞工數、平均工資、工資總額、最高工資
import java.util.*;
import java.util.stream.Collectors;
public class StreamTest {
public static void main(String[] args) {
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
personList.add(new Person("Anni", 8200, 24, "female", "New York"));
personList.add(new Person("Owen", 9500, 25, "male", "New York"));
personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
// 求員工總數
Long count = personList.stream().collect(Collectors.counting());
// 求平均工資
Double averageSalary = personList.stream().collect(Collectors.averagingDouble(Person::getSalary));
// 求最高工資
Optional<Integer> maxSalary = personList.stream().map(Person::getSalary).collect(Collectors.maxBy(Integer::compare));
// 求工資之和
Integer sumSalary = personList.stream().collect(Collectors.summingInt(Person::getSalary));
// 一次性統計所有資訊
DoubleSummaryStatistics collect = personList.stream().collect(Collectors.summarizingDouble(Person::getSalary));
System.out.println("員工總數為：" + count);
System.out.println("員工平均工資為：" + averageSalary);
System.out.println("員工最高工資為：" + maxSalary);
System.out.println("員工工資總和為：" + sumSalary);
System.out.println("員工工資所有統計：" + collect);
}
}
分組（partitioningBy/groupingBy）
- partitioningBy：分區。将 stream 按條件分為兩個 map，比如将員工按工資是否高于8000分為兩部分；
- groupingBy：分組。将集合分為多個 map，比如将員工按照性别分組。
import java.util.*;
import java.util.stream.Collectors;
public class StreamTest {
public static void main(String[] args) {
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
personList.add(new Person("Anni", 8200, 24, "female", "New York"));
personList.add(new Person("Owen", 9500, 25, "male", "New York"));
personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
// 将員工按薪資是否高于8000分組
Map<Boolean, List<Person>> part = personList.stream().collect(Collectors.partitioningBy(x -> x.getSalary() > 8000));
System.out.println("員工按薪資是否大于8000分組情況：");
System.out.println(part);
Map<String, List<Person>> group = personList.stream().collect(Collectors.groupingBy(Person::getSex));
System.out.println("員工按性别分組情況：");
System.out.println(group);
// 将員工先按性别分組，再按地區分組
Map<String, Map<String, List<Person>>> group2 = personList.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getArea)));
System.out.println("員工按性别、地區：");
System.out.println(group2);
}
}
接合（joining）
joining 可以将 stream 中的元素用特定的連接配接符連接配接成一個字元串
import java.util.*;
import java.util.stream.Collectors;
public class StreamTest {
public static void main(String[] args) {
List<String> list = Arrays.asList("A", "B", "C");
String string = list.stream().collect(Collectors.joining("-"));
System.out.println("拼接後的字元串：" + string);
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
personList.add(new Person("Anni", 8200, 24, "female", "New York"));
personList.add(new Person("Owen", 9500, 25, "male", "New York"));
personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
String names = personList.stream().map(p -> p.getName()).collect(Collectors.joining(","));
System.out.println("所有員工的姓名：" + names);
}
}
歸約（reducing）
Collectors 類提供的 reducing 方法，相比于 stream 本身的 reduce 方法，增加了對自定義歸約的支援
import java.util.*;
import java.util.stream.Collectors;
public class StreamTest {
public static void main(String[] args) {
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
personList.add(new Person("Anni", 8200, 24, "female", "New York"));
personList.add(new Person("Owen", 9500, 25, "male", "New York"));
personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
// 每個員工的工資減去5000之後的薪資之和
Integer sum = personList.stream().collect(Collectors.reducing(0, Person::getSalary, (i, j) -> (i + j - 5000)));
System.out.println("員工薪資總和：" + sum);
// stream的reduce
Optional<Integer> sum2 = personList.stream().map(Person::getSalary).reduce(Integer::sum);
System.out.println("員工薪資總和：" + sum2.get());
}
}
排序（sorted）
sorted()：自然排序，流中元素需要實作 Comparable 接口
sorted(Comparator com)：Comparator 排序器自定義排序
例：将員工按照工資排序
import java.util.*;
import java.util.stream.Collectors;
public class StreamTest {
public static void main(String[] args) {
List<Person> personList = new ArrayList<Person>();
personList.add(new Person("Tom", 8900, 23, "male", "New York"));
personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
personList.add(new Person("Lily", 7800, 21, "female", "Washington"));
personList.add(new Person("Anni", 8200, 24, "female", "New York"));
personList.add(new Person("Owen", 9500, 25, "male", "New York"));
personList.add(new Person("Alisa", 7900, 26, "female", "New York"));
// 按工資升序排序
List<String> newList = personList.stream().sorted(Comparator.comparing(Person::getSalary)).map(Person::getName)
.collect(Collectors.toList());
// 按工資降序排序
List<String> newList2 = personList.stream().sorted(Comparator.comparing(Person::getSalary).reversed())
.map(Person::getName).collect(Collectors.toList());
// 先按工資再按年齡自然排序（降序）
List<String> newList3 = personList.stream().sorted(Comparator.comparing(Person::getSalary).reversed())
.map(Person::getName).collect(Collectors.toList());
// 先按工資再按年齡自定義排序（升序）
List<String> newList4 = personList.stream().sorted((p1, p2) -> {
if (p1.getSalary() == p2.getSalary()) {
return p2.getAge() - p1.getAge();
} else {
return p1.getSalary() - p2.getSalary();
}
}).map(Person::getName).collect(Collectors.toList());
System.out.println("按工資升序自然排序：" + newList);
System.out.println("按工資降序排序：" + newList2);
System.out.println("先按工資再按年齡自然排序：" + newList3);
System.out.println("先按工資再按年齡自定義排序：" + newList4);
}
}
提取/組和
流也可以進行合并、去重、限制、跳過等操作
package demo;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class StreamTest {
public static void main(String[] args) {
String[] arr1 = { "a", "b", "c", "d" };
String[] arr2 = { "d", "e", "f", "g" };
String[] arr3 = {"A", "B", "C", "D"};
String[] arr4 = {"D", "E", "F", "G"};
Stream<String> stream1 = Stream.of(arr1);
Stream<String> stream2 = Stream.of(arr2);
Stream<String> stream3 = Stream.of(arr3);
Stream<String> stream4 = Stream.of(arr4);
// concat:合并兩個流
List<String> listConcat = Stream.concat(stream1,stream2).collect(Collectors.toList());
System.out.println("合并兩個流：" + listConcat);
// concat:合并兩個流 distinct：去重
List<String> listDistinct = Stream.concat(stream3, stream4).distinct().collect(Collectors.toList());
System.out.println("合并兩個流并去重：" + listDistinct);
// limit：限制從流中獲得前n個資料
// 從1開始，擷取10個逐個+2的數
List<Integer> limit = Stream.iterate(1, x -> x + 2).limit(10).collect(Collectors.toList());
System.out.println("limit：" + limit);
// skip：跳過前n個資料
// 從1開始，擷取5個逐個+2的數，但是跳過第一個
List<Integer> skip= Stream.iterate(1, x -> x + 2).skip(1).limit(5).collect(Collectors.toList());
System.out.println("skip：" + skip);
}
}
想要了解更多關于 Java 8 文法的示例，請移步至：https://blog.csdn.net/jiaomubai/article/details/111031943