引入流
流是什么
流是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限制，該流也會無限長，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/519257.html
標籤：其他
上一篇：樹結構