Java 8 Stream API 引入和使用

引入流

流是什麼

流是Java API的新成員，它允許你以宣告性的方式處理資料集合。可以看成遍歷資料集的高階迭代。流可以透明地並行處理，無需編寫多執行緒程式碼。我們先簡單看一下使用流的好處。下面兩段程式碼都是用來返回年齡小於14歲的初中生的姓名，並按照年齡排序。

假如我們有下面Student實體類

@Data
public class Student {
    private String name;
    private int age;
    private boolean member;
    private Grade grade;
    public Student() {
    }
    public Student(String name, int age, boolean member, Grade grade) {
        this.name = name;
        this.age = age;
        this.member = member;
        this.grade = grade;
    }
    public enum Grade{
        JUNIOR_ONE,JUNIOR_TWO,JUNIOR_THREE
    }
}

Java 8之前的實現方式：

List<Student> students = Arrays.asList(
        new Student("張初一", 13, false, Student.Grade.JUNIOR_ONE),
        new Student("李初二", 14, false, Student.Grade.JUNIOR_TWO),
        new Student("孫初三", 15, false, Student.Grade.JUNIOR_THREE),
        new Student("王初一", 12, false, Student.Grade.JUNIOR_ONE),
        new Student("錢初二", 14, false, Student.Grade.JUNIOR_TWO),
        new Student("周初三", 16, false, Student.Grade.JUNIOR_THREE));
List<Student> resultStudent = new ArrayList<>(); //垃圾變數，一次性的中間變數
//foreach迴圈，根據條件篩選元素
for (Student student : students) {
    if (student.getAge() < 14) {
        resultStudent.add(student);
    }
}
//匿名類，給元素排序
Collections.sort(resultStudent, new Comparator<Student>() {
    @Override
    public int compare(Student o1, Student o2) {
        return Integer.compare(o1.getAge(), o2.getAge());
    }
});
List<String> resultName = new ArrayList<>();
//foreach迴圈，獲取元素屬性
for (Student student : resultStudent) {
    resultName.add(student.getName());
}

Java 8流的實現方式：

List<String> resultName = students.stream()
        .filter(student -> student.getAge() < 14) //年齡篩選
        .sorted(Comparator.comparing(Student::getAge)) //年齡排序
        .map(Student::getName) //提取姓名
        .collect(Collectors.toList());//將提取的姓名儲存在List中

為了利用多核架構並行執行這段程式碼，只需要把stream()替換成parallelStream()即可。

通過對比兩段程式碼之後，Java8流的方式有幾個顯而易見的好處。

程式碼是以宣告性的方式寫的：說明想要做什麼（篩選小於14歲的學生）而不是去說明怎麼去做（迴圈、if）
將幾個基礎操作連結起來，表達複雜的資料處理流水線（filter->sorted->map->collect）,同時保持程式碼清晰可讀。

總結一下，Java 8的Stream API帶來的好處：

宣告性-更簡潔，更易讀
可複合-更靈活
可並行-效能更好

流簡介

流到底是什麼？簡單定義：「從支援資料處理操作的源生成的元素序列」，下面剖析這個定義。

元素序列：像集合一樣，流也提供了一個介面，可以存取特定元素型別的一組有序值。集合講的是資料，流講的是計算。
源：流使用一個提供資料的源，如集合、陣列或輸入/輸出資源。
資料處理操作：流的資料處理功能之處類似於資料庫的操作，以及函數語言程式設計語言中的常用操作，如filter、map、reduce、find、match、sort等。流的操作可以順序執行，也可以並行執行。
流水線：很多流的操作會返回一個流，這樣多個操作就可以連結起來，形成一個流水線。可以看成資料庫式查詢。
內部迭代：於迭代器顯示迭代的不同，流的迭代操作是在背後進行的。

看一段程式碼，更好理解這些概念

List<String> resultName = students.stream() //從列表中獲取流
        .filter(student -> student.getAge() < 16) //操作流水線：篩選
        .map(Student::getName) //操作流水線：提取姓名
        .limit(2) //操作流水線：只取2個
        .collect(Collectors.toList());//將結果儲存在List中

在上面程式碼中，資料來源是學生列表（students），用來給流提供一個元素序列，呼叫stream()獲取一個流，接下來就是一系列資料處理操作：filter、map、limit和collect。除collect之外，所有這些操作都會返回一個流，組成了一條流水線。最後collect操作開始處理流水線，並返回結果。

流與集合

粗略的說，流與集合之間的差異就在於什麼時候進行計算。

集合是一個記憶體中的資料結構（可以新增或者刪除），它包含資料結構中目前所有的值——集合中的每個元素都是預先處理好然後新增到集合中的。
流則是在概念上固定的資料結構（不能新增或刪除元素），其元素是按需計算的。

在哲學中，流被看作在時間中分佈的一組值，而集合則是空間（計算機記憶體）中分佈的一組值，在一個時間點上全體存在。

只能遍歷一次

和迭代器類似，流只能遍歷一次。遍歷完成之後，我們說這個流已經被消費掉了。

例如下面的程式碼會丟擲異常

Stream<Student> stream = students.stream();
stream.forEach(System.out::println);
stream.forEach(System.out::println);

執行之後丟擲如下異常：

Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
	at java.util.stream.AbstractPipeline.sourceStageSpliterator(AbstractPipeline.java:279)
	at java.util.stream.ReferencePipeline$Head.forEach(ReferencePipeline.java:580)
	at com.example.demo.java8.stream.StreamTest.main(StreamTest.java:58)

所以要記得，流只能消費一次。

外部迭代與內部迭代

我們使用iterator或者foreach遍歷集合時的這種迭代方式被稱為外部迭代，而Streams庫使用內部迭代，它幫你把迭代做了，還把得到的流值存在了某個地方，你只要給出一個函數說要幹什麼就可以了。

下面的程式碼說明了這種區別。

外部迭代

//使用增強for迴圈做外部迭代，底層還是迭代器
List<String> resultName = new ArrayList<>();
for (Student student : students) {
    resultName.add(student.getName());
}
//使用迭代器做外部迭代
Iterator<Student> iterator = students.iterator();
while (iterator.hasNext()){
    Student student = iterator.next();
    resultName.add(student.getName());
}

內部迭代

List<String> resultName = students.stream()
        .map(Student::getName)
        .collect(Collectors.toList());

流操作

java.util.stream中的Stream介面定義了許多操作。可以分為兩大類。先看一下下面這個例子：

List<String> resultName = students.stream() //從列表中獲取流
        .filter(student -> student.getAge() < 16) //中間操作
        .map(Student::getName) //中間操作
        .limit(2) //中間操作
        .collect(Collectors.toList());//將Stream轉為List

可以看到兩類操作：

filter、map和limit連結的一條流水線
collect觸發流水線執行並關閉它
流水線中流的操作稱為中間操作，關閉流的操作稱為終端操作

中間操作

諸如filter或sorted等中間操作會返回一個流，這讓很多操作連結起來形成一個複合的流水線（查詢）。重要的是，除非流水線上觸發一個終端操作，否則中間操作不會執行任何處理——它們很懶（延遲計算/惰性求值）。
因為中間操作一般都可以合併起來，在終端操作時一次性全部處理。
修改一下上面的程式碼，看一下發生了什麼：

List<String> resultName = students.stream() //從列表中獲取流
        .filter(student -> {
            System.out.println("filter："+student.getName());
            return student.getAge() < 16;
        }) //中間操作
        .map(student -> {
            System.out.println("map："+student.getName());
            return student.getName();
        }) //中間操作
        .limit(3) //中間操作
        .collect(Collectors.toList());//將Stream轉為List

執行結果如下：

filter：張初一
map：張初一
filter：李初二
map：李初二
filter：孫初三
map：孫初三

可以發現，利用流的延遲性質實現了幾個好的優化。limit操作實現了只選擇前3個，filter和map操作是相互獨立的操作，但他們合併到同一次遍歷中。

終端操作

終端操作會從流的流水線生成結果。其結果可以是任何不是流的值，例如List、Integer，亦或是void等。

流的使用

流的使用一般包括三件事：

一個資料來源（如集合）來執行一個查詢
一箇中間操作鏈，形成一條流水線
一個終端操作，執行流水線，並生成結果

流的流水線背後的理念類似於構建器模式。在構建器模式中有一個呼叫鏈來設定一套設定（對流來說這就是一箇中間操作鏈），接著時呼叫build方法（對流來說就是終端操作）。

使用流

Stream API支援許多操作，這些操作能幫助我們快速完成複雜的資料查詢，如篩選、切片、對映、查詢、匹配和歸約。

篩選和切片

用謂詞篩選，篩選出各不相同的元素，忽略流中的頭幾個元素，或將流截短至指定長度。

用謂詞篩選 `filter`

流支援filter方法，該方法接受一個謂詞（一個返回boolean的函數）作為引數，並返回一個包括所有符合謂詞的元素的流。例如，下面的程式碼就是篩選是團員的學生：

List<Student> memberList = students.stream()
        .filter(Student::isMember) //方法參照檢查學生是否是團員
        .collect(Collectors.toList());

去重元素 `distinct`

流支援distinct方法，該方法可以將列表中的元素去重（根據流所生成元素的hashCode和equals方法實現）的流。例如下面的程式碼事篩選列表中的偶數，並去重：

List<Integer> numberList = Arrays.asList(1, 2, 3, 4, 5, 6, 2, 4, 6);
numberList.stream()
        .filter(n -> n % 2 == 0)
        .distinct()
        .forEach(System.out::println);

截短流 `limit`

流支援limit(n)方法，該方法返回一個不超過給定長度的流。如果是有序的流，則最多返回前n個元素。例如，篩選出小於14歲的前三個學生：

List<Student> studentList = students.stream()
        .filter(student -> student.getAge() < 14)
        .limit(3)
        .collect(Collectors.toList());

跳過元素 `skip`

流支援skip(n)方法，該方法返回一個跳過了前n個元素的流。如果流中的元素不足n個，則返回一個空流。例如，跳過年齡小於14歲的頭三個學生，返回剩下的。

List<Student> studentList = students.stream()
        .filter(student -> student.getAge() < 14)
        .skip(3)
        .collect(Collectors.toList());

對映

有時候當我們在處理資料時，需要從一系列物件中提取某個屬性值，比如從SQL表中選擇一列。Stream API通過map和flatMap方法提供了類似的工具。

對流中的每一個元素應用函數 `map`

流支援map方法，該方法接受一個函數作為引數。這個函數會被應用到每個元素上，並將其對映成一個新的元素。例如，需要提取學生列表中的學生姓名：

List<String> studentList = students.stream()
        .map(Student::getName)//getName會返回String，此時map返回的就是Stream<String>
        .collect(Collectors.toList());

如果需要進一步操作，例如獲取姓名的長度，在連結上一個map即可：

List<Integer> studentList = students.stream()
        .map(Student::getName)
        .map(String::length)
        .collect(Collectors.toList());

流的扁平化 `flatMap`

先舉個例子，我們需要從["hello", "world"]單詞列表中提取每個字元並去重，結果應該是["h", "e", "l", "o", "w", "r", "d"]。

我們可能會寫出下面這樣的程式碼：

List<String> wordList = Arrays.asList("hello","word");
List<String[]> result = wordList.stream()
        .map(word -> word.split(""))
        .distinct()
        .collect(Collectors.toList());

但實際上map返回的是Stream<String[]>，或者我們又寫出下面這樣的程式碼：

List<String> wordList = Arrays.asList("hello","word");
List<Stream<String>> result = wordList.stream()
        .map(word -> word.split(""))
        .map(Arrays::stream)
        .distinct()
        .collect(Collectors.toList());

但實際上map返回的是Stream<Stream<String>>，而我們真想想要的是Stream<String> 。

這時候flatMap就派上用場了：

List<String> wordList = Arrays.asList("hello","word");
List<String> result = wordList.stream()
        .map(w -> w.split(""))
        .flatMap(Arrays::stream)
        .distinct()
        .collect(Collectors.toList());
System.out.println(result);

map(Arrays::stream)是將每個元素都對映成一個流，而flatMap方法效果將對映的流合併起來，即扁平化一個流。意思就是將流中的每個值都轉換成一個流，然後把所有的流連線起來成為一個流

查詢和匹配

還有在處理資料時，我們會判斷一個集合中的某些元素是否符合給定的條件。Stream API通過allMatch、anyMatch、noneMatch、findFirst和findAny方法提供了這樣的工具。

檢查謂詞是否至少匹配一個元素 `anyMatch`

anyMatch方法可以用來判斷「流中是否有一個元素能匹配給定的謂詞」。

if(students.stream().anyMatch(Student::isMember)) {
    System.out.println("學生列表中至少有一個是團員！");
}

anyMatch方法返回一個boolean，是一個終端操作。

檢查謂詞是否匹配所有元素 `allMatch` `noneMatch`

allMatch方法可以用來判斷「流中是否所有的元素都能匹配給定的謂詞」

if (students.stream().allMatch(student -> student.getAge() < 18)) {
    System.out.println("學生列表中所有學生的年齡都小於18歲！");
}

noneMatch和allMatch是相對的，用來判斷「流中的所有元素都不能匹配給定的謂詞」

if (students.stream().noneMatch(student -> student.getAge() >= 18)) {
    System.out.println("學生列表中沒有學生的年齡大於等於18歲！");
}

anyMatch、allMatch和noneMatch這三個操作都用到了我們所謂的短路，這就是我們熟悉的Java中的&&和||運運算元短路在流中的版本。

查詢元素 `findAny`

findAny方法返回當前流中的任意元素。可與其他流操作相結合使用。例如，我們需要找到一個學生列表中的團員：

Optional<Student> studentOptional = students.stream()
        .filter(Student::isMember)
        .findAny();

不過這個Optional是什麼？

Optional簡介
Optional<T>類(java.util.Optional)是一個容器類，代表一個值存在或不存在。上面程式碼中有可能什麼元素都沒有找到。Java 8引入Optional<T>用來避免null帶來的異常。

先簡單瞭解下它的幾個方法：

isPresent()：若Optional包含值則返回true，否則返回false。
ifPresent(Consumer<? super T> consumer)：若Optional包含值時執行給定的程式碼。引數是Consumer，一個函數式介面。
T get()：若Optional包含值時返回該值，否則丟擲NoSuchElementException異常。
T orElse(T other)：若Optional包含值時返回該值，否則返回指定預設值。

例如，前面的studentOptional若包含一個學生，我們就列印該學生的姓名，否則就什麼也不做。

studentOptional.ifPresent(student -> System.out.println(student.getName()));

查詢第一個元素 `findFirst`

findFirst方法返回當前流中的第一個元素。在某些順序流中，我們要找到第一個元素，這時可以使用findFirst，例如，給定一個數位列表，找到其中第一個平方根能被2整除的數：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
Optional<Integer> first = numbers.stream()
        .map(n -> n * n)
        .filter(n -> n % 2 == 0)
        .findFirst();
first.ifPresent(n -> System.out.println(n));// 4

我們會發現findAny和findFirst的工作方式是類似的，那我們什麼時候使用findFirst和findAny呢？
findFirst在並行上限制很多，所以如果不關心返回元素是哪一個（不關心順序），請使用findAny，因為在並行時限制較少。

歸約 `reduce`

reduce操作可以將一個流中的元素組合起來，得到一個值。

元素求和

使用foreach迴圈求和：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
int sum = 0;
for (Integer number : numbers) {
    sum += number;
}

這裡通過反覆加法，把一個列表歸約成一個數位。如果是計算相乘的結果，是不是還要複製貼上這段程式碼？大可不必，reduce操作將這種模式做了抽象。用reduce求和：

Integer sum = numbers.stream().reduce(0, (a, b) -> a + b);

這裡reduce()接受兩個引數:

初始值，這裡是0
BinaryOperator<T>組合兩個元素產生新值，這裡是Lambda(a, b) -> a + b
如果是相乘，則只需傳遞Lambda(a, b) -> a * b即可：

Integer result = numbers.stream().reduce(0, (a, b) -> a * b);

Java 8中，Integer類有了static int sum(int a, int b)方法來求兩個數的和，這剛好是BinaryOperator型別的值，所以程式碼可以更精簡，更易讀：

Integer sum = numbers.stream().reduce(0, Integer::sum);

reduce還有一個過載版本，不接受初始值，返回一個Optional<T>物件，考慮流中沒有任何元素，也沒有初始值，所以reduce無法返回結果，此時Optional中的值就不存在。

最大值和最小值

類比求和的操作，我們傳遞Lambda(a, b) -> a > b ? a : b即可：

numbers.stream().reduce((a, b) -> a > b ? a : b);

相同的Java 8中的Integer也新增了max和min來求兩個數中的最大和最小值，則可以寫成：

Optional<Integer> max = numbers.stream().reduce(Integer::max);
Optional<Integer> min = numbers.stream().reduce(Integer::min);

數值流

前面用reduce計算流中元素的中和，現在我想計算學生列表中學生的年齡總和，就可以這麼寫：

students.stream().map(Student::getAge)
        .reduce(0, Integer::sum);

但是這裡暗含了裝箱成本。Integer需要被拆箱成原始型別，在進行求和。所以Stream API提供了原始型別流特化，專門支援處理數流的方法。

原始型別流

Java 8中引入了三個原始型別流：IntStream、DoubleStream和LongStream，分別將流中的元素轉化為int、long和double，從而避免暗含裝箱成本。每個介面都帶來了進行常用數值歸約的新方法，如對數值流求和的sum，找到最大元素的max，還可以把它們再轉回物件流。

對映到數值流 mapToInt mapToDouble mapToLong

students.stream()
        .mapToInt(Student::getAge)
        .sum();

轉回物件流 .boxed()

Stream<Integer> stream = students.stream()
        .mapToInt(Student::getAge)
        .boxed();

預設值 OptionalInt OptionalDouble OptionalLong

OptionalInt optionalInt = students.stream()
        .mapToInt(Student::getAge)
        .max();

數值範圍 `range` `rangeClosed`

Java 8引入了兩個可以用於IntStream和LongStream的靜態方法，幫助我們生成一個數值範圍。range和rangeClosed，兩個方法接收兩個引數第一個是起始值，第二個是結束值。前者不包含結束值，後者包含結束值。

IntStream range = IntStream.range(1, 100);
System.out.println(range.count());//99
IntStream intStream = IntStream.rangeClosed(1, 100);
System.out.println(intStream.count());//100

數值流例子

100以內的勾股數：a*a + b*b = c*c，a、b、c都是整數。

IntStream.rangeClosed(1, 100)
        .boxed()
        .flatMap(a ->
                IntStream.rangeClosed(a, 100)
                        .mapToObj(b -> new double[]{a, b, Math.sqrt(a * a + b * b)})
                        .filter(ints -> ints[2] % 1 == 0))
        .forEach(t -> 
                System.out.println((int) t[0] + "--" + (int) t[1] + "--" + (int) t[2]));

構建流

前面我們已經瞭解了很多流的的操作，並且知道通過stream方法從集合生成流以及根據數值範圍建立數值流。下面我們我們介紹如何從序列、陣列、檔案和生成函數來建立流。

由序列建立流 `Stream.of`

使用靜態方法Stream.of顯示的建立一個流，該方法接受任意數量的引數。

//建立一個字串流
Stream<String> stringStream = Stream.of("A", "B", "C", "D", "E");
//建立一個空流
Stream.empty();

由陣列建立流 `Arrays.stream`

使用靜態方法Arrays.stream從陣列建立一個流，該方法接受一個陣列引數。

int[] num = {1,2,3,4,5};
IntStream stream = Arrays.stream(num);
System.out.println(stream.sum());//15

由檔案生成流

Java 8更新了NIO API（非阻塞 I/O），其中java.nio.file.Files中新增了許多靜態方法可以返回一個流，如Files.lines()該方法接受一個檔案路徑物件（Path物件），返回由指定檔案中每一行組成的字串流。下面的程式碼用來計算這個檔案中有多少個不同的字元：

try (Stream<String> lines = Files.lines(Paths.get("C:\\Users\\symon\\Desktop\\test.txt"), Charset.defaultCharset())) {
    long count = lines
            .flatMap(line -> {
                System.out.println(line);
                return Arrays.stream(line.split(""));
            })
            .distinct()
            .count();
    System.out.println(count);
} catch (IOException e) {
    e.printStackTrace();
}

由函數生成流，建立無限流

Stream API提供了兩個靜態方法來生成流：Stream.iterate()和Stream.generate()。這兩個操作可以建立所謂的無限流：沒有固定大小的流。一般來說，會使用limit(n)來進行限制，避免無盡地計算下去。

迭代 `Stream.iterate`

Stream.iterate(0, n -> n + 2)
        .limit(20)
        .forEach(System.out::println);

iterate方法接受一個初始值（這裡是0），還有一個依次應用在每個產生的新值上的Lambda（UnaryOperator<T>型別）。這裡是n -> n + 2，返回前一個元素加2。所以上面程式碼生成了一個正偶數流。如果不加limit限制，則會永遠計算下去。

生成 `Stream.generate`

Stream.generate(Math::random)
        .limit(10)
        .forEach(System.out::println);

generate方法接受一個Supplier<T>型別的Lambda作為引數，不會像iterate一樣對每個新生成的值應用函數。上面程式碼是取10個0~1之間的亂數。同樣，如果不加limit限制，該流也會無限長。

Java 8 Stream API 引入和使用

引入流

流是什麼

流簡介

流與集合

只能遍歷一次

外部迭代與內部迭代

流操作

中間操作

終端操作

流的使用

使用流

篩選和切片

用謂詞篩選 filter

去重元素 distinct

截短流 limit

跳過元素 skip

對映

對流中的每一個元素應用函數 map

流的扁平化 flatMap

查詢和匹配

檢查謂詞是否至少匹配一個元素 anyMatch

檢查謂詞是否匹配所有元素 allMatch noneMatch

查詢元素 findAny

查詢第一個元素 findFirst

歸約 reduce