Stream
Stream介紹
Stream 使用一種類似用 SQL 語句從數據庫查詢數據的直觀方式來提供一種對 Java 集合運算和表達的高階抽象。Stream API可以極大提高Java程序員的生產力，讓程序員寫出高效率、干凈、簡潔的代碼。這種風格將要處理的元素集合看作一種流， 流在管道中傳輸， 并且可以在管道的節點上進行處理， 比如篩選， 排序，聚合等。
Stream特性：
不是數據結構：它沒有內部存儲，它只是用操作管道從 source（數據結構、數組、generator function、IO channel）抓取數據。它也絕不修改自己所封裝的底層數據結構的數據。例如 Stream 的 filter 操作會產生一個不包含被過濾元素的新 Stream，而不是從 source 刪除那些元素。
不支持索引訪問：但是很容易生成數組或者 List 。
惰性化：很多 Stream 操作是向后延遲的，一直到它弄清楚了最后需要多少數據才會開始。Intermediate 操作永遠是惰性化的。
并行能力。當一個 Stream 是并行化的，就不需要再寫多線程代碼，所有對它的操作會自動并行進行的。
可以是無限的：集合有固定大小，Stream 則不必。limit(n) 和 findFirst() 這類的 short-circuiting 操作可以對無限的 Stream 進行運算并很快完成。
注意事項：所有 Stream 的操作必須以 lambda 表達式為參數。
Stream 流操作類型：
Intermediate：一個流可以后面跟隨零個或多個 intermediate 操作。其目的主要是打開流，做出某種程度的數據映射/過濾，然后返回一個新的流，交給下一個操作使用。這類操作都是惰性化的（lazy），就是說，僅僅調用到這類方法，并沒有真正開始流的遍歷。
Terminal：一個流只能有一個 terminal 操作，當這個操作執行后，流就被使用“光”了，無法再被操作。所以這必定是流的最后一個操作。Terminal操作的執行，才會真正開始流的遍歷，并且會生成一個結果，或者一個 side effect。
Stream使用
這里我們依舊使用一個簡單示例來看看吧。在開發中，我們有時需要對一些數據進行過濾，如果是傳統的方式，我們需要對這批數據進行遍歷過濾，會顯得比較繁瑣，如果使用steam流方式的話，那么可以很方便的進行處理。
首先通過普通的方式進行過濾:
List list = Arrays.asList(“張三”, “李四”, “王五”, “xuwujing”);
System.out.println(“過濾之前:” + list);
List result = new ArrayList<>();
for (String str : list) {
if (!“李四”.equals(str)) {
result.add(str);
}
}
System.out.println(“過濾之后:” + result);
使用Steam方式進行過濾：
List result2 = list.stream().filter(str -> !“李四”.equals(str)).collect(Collectors.toList());
System.out.println(“stream 過濾之后:” + result2);
輸出結果:
過濾之前:[張三, 李四, 王五, xuwujing]
過濾之后:[張三, 王五, xuwujing]
stream 過濾之后:[張三, 王五, xuwujing]
是不是很簡潔和方便呢。其實Stream流還有更多的使用方法，filter只是其中的一角而已。那么在這里我們就來學習了解下這些用法吧。
1.構造Stream流的方式
Stream stream = Stream.of(“a”, “b”, “c”);
String[] strArray = new String[] { “a”, “b”, “c” };
stream = Stream.of(strArray);
stream = Arrays.stream(strArray);
List list = Arrays.asList(strArray);
stream = list.stream();
2.Stream流的之間的轉換
注意:一個Stream流只可以使用一次，這段代碼為了簡潔而重復使用了數次，因此會拋出 stream has already been operated upon or closed 異常。
try {
Stream stream2 = Stream.of(“a”, “b”, “c”);
// 轉換成 Array
String[] strArray1 = stream2.toArray(String[]::new);

// 轉換成 Collection
List list1 = stream2.collect(Collectors.toList());
List list2 = stream2.collect(Collectors.toCollection(ArrayList::new));
Set set1 = stream2.collect(Collectors.toSet());
Stack stack1 = stream2.collect(Collectors.toCollection(Stack::new));

// 轉換成 String
String str = stream.collect(Collectors.joining()).toString();
} catch (Exception e) {
e.printStackTrace();
}
3.Stream流的map使用
map方法用于映射每個元素到對應的結果，一對一。
示例一：轉換大寫
List list3 = Arrays.asList(“zhangSan”, “liSi”, “wangWu”);
System.out.println(“轉換之前的數據:” + list3);
List list4 = list3.stream().map(String::toUpperCase).collect(Collectors.toList());
System.out.println(“轉換之后的數據:” + list4);
// 轉換之后的數據:[ZHANGSAN, LISI,WANGWU]
示例二：轉換數據類型
List list31 = Arrays.asList(“1”, “2”, “3”);
System.out.println(“轉換之前的數據:” + list31);
List list41 = list31.stream().map(Integer::valueOf).collect(Collectors.toList());
System.out.println(“轉換之后的數據:” + list41);
// [1, 2, 3]
示例三：獲取平方
List list5 = Arrays.asList(new Integer[] { 1, 2, 3, 4, 5 });
List list6 = list5.stream().map(n -> n * n).collect(Collectors.toList());
System.out.println(“平方的數據:” + list6);
// [1, 4, 9, 16, 25]
4.Stream流的filter使用
filter方法用于通過設置的條件過濾出元素。
示例二：通過與 findAny 得到 if/else 的值
List list = Arrays.asList(“張三”, “李四”, “王五”, “xuwujing”);
String result3 = list.stream().filter(str -> “李四”.equals(str)).findAny().orElse(“找不到!”);
String result4 = list.stream().filter(str -> “李二”.equals(str)).findAny().orElse(“找不到!”);

System.out.println(“stream 過濾之后 2:” + result3);
System.out.println(“stream 過濾之后 3:” + result4);
//stream 過濾之后 2:李四
//stream 過濾之后 3:找不到!
示例三：通過與 mapToInt 計算和
List lists = new ArrayList();
lists.add(new User(6, “張三”));
lists.add(new User(2, “李四”));
lists.add(new User(3, “王五”));
lists.add(new User(1, “張三”));
// 計算這個list中出現 “張三” id的值
int sum = lists.stream().filter(u -> “張三”.equals(u.getName())).mapToInt(u -> u.getId()).sum();

System.out.println(“計算結果:” + sum);
// 7
5.Stream流的flatMap使用
flatMap 方法用于映射每個元素到對應的結果，一對多。
示例:從句子中得到單詞
String worlds = “The way of the future”;
List list7 = new ArrayList<>();
list7.add(worlds);
List list8 = list7.stream().flatMap(str -> Stream.of(str.split(" ")))
.filter(world -> world.length() > 0).collect(Collectors.toList());
System.out.println(“單詞:”);
list8.forEach(System.out::println);
// 單詞:
// The
// way
// of
// the
// future
6.Stream流的limit使用
limit 方法用于獲取指定數量的流。
示例一：獲取前n條數的數據
Random rd = new Random();
System.out.println(“取到的前三條數據:”);
rd.ints().limit(3).forEach(System.out::println);
// 取到的前三條數據:
// 1167267754
// -1164558977
// 1977868798
示例二：結合skip使用得到需要的數據
skip表示的是扔掉前n個元素。
List list9 = new ArrayList();
for (int i = 1; i < 4; i++) {
User user = new User(i, “pancm” + i);
list9.add(user);
}
System.out.println(“截取之前的數據:”);
// 取前3條數據，但是扔掉了前面的2條，可以理解為拿到的數據為 2<=i<3 (i 是數值下標)
List list10 = list9.stream().map(User::getName).limit(3).skip(2).collect(Collectors.toList());
System.out.println(“截取之后的數據:” + list10);
// 截取之前的數據:
// 姓名:pancm1
// 姓名:pancm2
// 姓名:pancm3
// 截取之后的數據:[pancm3]
注:User實體類中 getName 方法會打印姓名。
7.Stream流的sort使用
sorted方法用于對流進行升序排序。
示例一：隨機取值排序
Random rd2 = new Random();
System.out.println(“取到的前三條數據然后進行排序:”);
rd2.ints().limit(3).sorted().forEach(System.out::println);
// 取到的前三條數據然后進行排序:
// -2043456377
// -1778595703
// 1013369565
示例二：優化排序
tips:先獲取在排序效率會更高!
//普通的排序取值
List list11 = list9.stream().sorted((u1, u2) -> u1.getName().compareTo(u2.getName())).limit(3)
.collect(Collectors.toList());
System.out.println(“排序之后的數據:” + list11);
//優化排序取值
List list12 = list9.stream().limit(3).sorted((u1, u2) -> u1.getName().compareTo(u2.getName()))
.collect(Collectors.toList());
System.out.println(“優化排序之后的數據:” + list12);
//排序之后的數據:[{“id”:1,“name”:“pancm1”}, {“id”:2,“name”:“pancm2”}, {“id”:3,“name”:“pancm3”}]
//優化排序之后的數據:[{“id”:1,“name”:“pancm1”}, {“id”:2,“name”:“pancm2”}, {“id”:3,“name”:“pancm3”}]
8.Stream流的peek使用
peek對每個元素執行操作并返回一個新的Stream
示例:雙重操作
System.out.println(“peek使用:”);
Stream.of(“one”, “two”, “three”, “four”).filter(e -> e.length() > 3).peek(e -> System.out.println("轉換之前: " + e))
.map(String::toUpperCase).peek(e -> System.out.println("轉換之后: " + e)).collect(Collectors.toList());

// 轉換之前: three
// 轉換之后: THREE
// 轉換之前: four
// 轉換之后: FOUR
9.Stream流的parallel使用
parallelStream 是流并行處理程序的代替方法。
示例:獲取空字符串的數量
List strings = Arrays.asList(“a”, “”, “c”, “”, “e”,"", " “);
// 獲取空字符串的數量
long count = strings.parallelStream().filter(string -> string.isEmpty()).count();
System.out.println(“空字符串的個數:”+count);
10.Stream流的max/min/distinct使用
示例一：得到最大最小值
List list13 = Arrays.asList(“zhangsan”,“lisi”,“wangwu”,“xuwujing”);
int maxLines = list13.stream().mapToInt(String::length).max().getAsInt();
int minLines = list13.stream().mapToInt(String::length).min().getAsInt();
System.out.println(“最長字符的長度:” + maxLines+”,最短字符的長度:"+minLines);
//最長字符的長度:8,最短字符的長度:4
示例二：得到去重之后的數據
String lines = “good good study day day up”;
List list14 = new ArrayList();
list14.add(lines);
List words = list14.stream().flatMap(line -> Stream.of(line.split(" “))).filter(word -> word.length() > 0)
.map(String::toLowerCase).distinct().sorted().collect(Collectors.toList());
System.out.println(“去重復之后:” + words);
//去重復之后:[day, good, study, up]
11.Stream流的Match使用
allMatch：Stream 中全部元素符合則返回 true ;
anyMatch：Stream 中只要有一個元素符合則返回 true;
noneMatch：Stream 中沒有一個元素符合則返回 true。
示例:數據是否符合
boolean all = lists.stream().allMatch(u -> u.getId() > 3);
System.out.println(“是否都大于3:” + all);
boolean any = lists.stream().anyMatch(u -> u.getId() > 3);
System.out.println(“是否有一個大于3:” + any);
boolean none = lists.stream().noneMatch(u -> u.getId() > 3);
System.out.println(“是否沒有一個大于3的:” + none);
// 是否都大于3:false
// 是否有一個大于3:true
// 是否沒有一個大于3的:false
12.Stream流的reduce使用
reduce 主要作用是把 Stream 元素組合起來進行操作。
示例一：字符串連接
String concat = Stream.of(“A”, “B”, “C”, “D”).reduce(”", String::concat);
System.out.println(“字符串拼接:” + concat);
示例二：得到最小值
double minValue = Stream.of(-4.0, 1.0, 3.0, -2.0).reduce(Double.MAX_VALUE, Double::min);
System.out.println(“最小值:” + minValue);
//最小值:-4.0
示例三：求和
// 求和, 無起始值
int sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();
System.out.println(“有無起始值求和:” + sumValue);
// 求和, 有起始值
sumValue = Stream.of(1, 2, 3, 4).reduce(1, Integer::sum);
System.out.println(“有起始值求和:” + sumValue);
// 有無起始值求和:10
// 有起始值求和:11
示例四：過濾拼接
concat = Stream.of(“a”, “B”, “c”, “D”, “e”, “F”).filter(x -> x.compareTo(“Z”) > 0).reduce("", String::concat);
System.out.println(“過濾和字符串連接:” + concat);
//過濾和字符串連接:ace
13.Stream流的iterate使用
iterate 跟 reduce 操作很像，接受一個種子值，和一個UnaryOperator（例如 f）。然后種子值成為 Stream 的第一個元素，f(seed) 為第二個，f(f(seed)) 第三個，以此類推。在 iterate 時候管道必須有 limit 這樣的操作來限制 Stream 大小。
示例:生成一個等差隊列
System.out.println(“從2開始生成一個等差隊列:”);
Stream.iterate(2, n -> n + 2).limit(5).forEach(x -> System.out.print(x + " "));
// 從2開始生成一個等差隊列:
// 2 4 6 8 10
14.Stream流的Supplier使用
通過實現Supplier類的方法可以自定義流計算規則。
示例：隨機獲取兩條用戶信息
System.out.println(“自定義一個流進行計算輸出:”);
Stream.generate(new UserSupplier()).limit(2).forEach(u -> System.out.println(u.getId() + ", " + u.getName()));

//第一次:
//自定義一個流進行計算輸出:
//10, pancm7
//11, pancm6

//第二次:
//自定義一個流進行計算輸出:
//10, pancm4
//11, pancm2

//第三次:
//自定義一個流進行計算輸出:
//10, pancm4
//11, pancm8

class UserSupplier implements Supplier {
private int index = 10;
private Random random = new Random();

@Override
public User get() {
return new User(index++, “pancm” + random.nextInt(10));
}
}
15.Stream流的groupingBy/partitioningBy使用
groupingBy：分組排序；
partitioningBy：分區排序。
示例一：分組排序
System.out.println(“通過id進行分組排序:”);
Map<Integer, List> personGroups = Stream.generate(new UserSupplier2()).limit(5)
.collect(Collectors.groupingBy(User::getId));
Iterator it = personGroups.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<Integer, List> persons = (Map.Entry) it.next();
System.out.println("id " + persons.getKey() + " = " + persons.getValue());
}

// 通過id進行分組排序:
// id 10 = [{“id”:10,“name”:“pancm1”}]
// id 11 = [{“id”:11,“name”:“pancm3”}, {“id”:11,“name”:“pancm6”}, {“id”:11,“name”:“pancm4”}, {“id”:11,“name”:“pancm7”}]

class UserSupplier2 implements Supplier {
private int index = 10;
private Random random = new Random();

@Override
public User get() {
return new User(index % 2 == 0 ? index++ : index, “pancm” + random.nextInt(10));
}
}
示例二：分區排序
System.out.println(“通過年齡進行分區排序:”);
Map<Boolean, List> children = Stream.generate(new UserSupplier3()).limit(5)
.collect(Collectors.partitioningBy(p -> p.getId() < 18));

System.out.println("小孩: " + children.get(true));
System.out.println("成年人: " + children.get(false));

// 通過年齡進行分區排序:
// 小孩: [{“id”:16,“name”:“pancm7”}, {“id”:17,“name”:“pancm2”}]
// 成年人: [{“id”:18,“name”:“pancm4”}, {“id”:19,“name”:“pancm9”}, {“id”:20,“name”:“pancm6”}]

class UserSupplier3 implements Supplier {
private int index = 16;
private Random random = new Random();

@Override
public User get() {
return new User(index++, “pancm” + random.nextInt(10));
}
}
16.Stream流的summaryStatistics使用
IntSummaryStatistics 用于收集統計信息(如count、min、max、sum和average)的狀態對象。
示例:得到最大、最小、之和以及平均數。
List numbers = Arrays.asList(1, 5, 7, 3, 9);
IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();

System.out.println("列表中最大的數 : " + stats.getMax());
System.out.println("列表中最小的數 : " + stats.getMin());
System.out.println("所有數之和 : " + stats.getSum());
System.out.println("平均數 : " + stats.getAverage());

// 列表中最大的數 : 9
// 列表中最小的數 : 1
// 所有數之和 : 25
// 平均數 : 5.0

總結

以上是生活随笔為你收集整理的JDK1.8 stream详解（转）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。