當前位置：首頁 > 编程语言 > java >内容正文

java

Java8 Stream 函数式接口

發布時間：2025/3/15 java 33 豆豆

生活随笔收集整理的這篇文章主要介紹了 Java8 Stream 函数式接口小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

在這里插入圖片描述

先貼上幾個案例，水平高超的同學可以挑戰一下：

從員工集合中篩選出salary大于8000的員工，并放置到新的集合里。
統計員工的最高薪資、平均薪資、薪資之和。
將員工按薪資從高到低排序，同樣薪資者年齡小者在前。
將員工按性別分類，將員工按性別和地區分類，將員工按薪資是否高于8000分為兩部分。
用傳統的迭代處理也不是很難，但代碼就顯得冗余了，跟Stream相比高下立判。

1 Stream概述

Java 8 是一個非常成功的版本，這個版本新增的Stream，配合同版本出現的 Lambda ，給我們操作集合（Collection）提供了極大的便利。

那么什么是Stream？

Stream將要處理的元素集合看作一種流，在流的過程中，借助Stream API對流中的元素進行操作，比如：篩選、排序、聚合等。

Stream可以由數組或集合創建，對流的操作分為兩種：

中間操作，每次返回一個新的流，可以有多個。

終端操作，每個流只能進行一次終端操作，終端操作結束后流無法再次使用。終端操作會產生一個新的集合或值。

另外，Stream有幾個特性：

stream不存儲數據，而是按照特定的規則對數據進行計算，一般會輸出結果。

stream不會改變數據源，通常情況下會產生一個新的集合或一個值。

stream具有延遲執行特性，只有調用終端操作時，中間操作才會執行。

2 Stream的創建

Stream可以通過集合數組創建。

1、通過 java.util.Collection.stream() 方法用集合創建流

List<String> list = Arrays.asList("a", "b", "c"); // 創建一個順序流 Stream<String> stream = list.stream(); // 創建一個并行流 Stream<String> parallelStream = list.parallelStream();

2、使用java.util.Arrays.stream(T[] array)方法用數組創建流

int[] array={1,3,5,6,8}; IntStream stream = Arrays.stream(array);

3、使用Stream的靜態方法：of()、iterate()、generate()

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 3).limit(4); stream2.forEach(System.out::println);Stream<Double> stream3 = Stream.generate(Math::random).limit(3); stream3.forEach(System.out::println);

輸出結果：

0 3 6 9 0.6796156909271994 0.1914314208854283 0.8116932592396652

stream和parallelStream的簡單區分： stream是順序流，由主線程按順序對流執行操作，而parallelStream是并行流，內部以多線程并行執行的方式對流進行操作，但前提是流中的數據處理沒有順序要求。例如篩選集合中的奇數，兩者的處理不同之處：

如果流中的數據量足夠大，并行流可以加快處速度。

除了直接創建并行流，還可以通過parallel()把順序流轉換成并行流：

Optional<Integer> findFirst = list.stream().parallel().filter(x->x>6).findFirst();

3 Stream的使用

在使用stream之前，先理解一個概念：Optional 。

Optional類是一個可以為null的容器對象。如果值存在則isPresent()方法會返回true，調用get()方法會返回該對象。

接下來，大批代碼向你襲來！我將用20個案例將Stream的使用整得明明白白，只要跟著敲一遍代碼，就能很好地掌握。
在這里插入圖片描述

案例使用的員工類
這是后面案例中使用的員工類：

List<Person> personList = new ArrayList<Person>(); personList.add(new Person("Tom", 8900, "male", "New York")); personList.add(new Person("Jack", 7000, "male", "Washington")); personList.add(new Person("Lily", 7800, "female", "Washington")); personList.add(new Person("Anni", 8200, "female", "New York")); personList.add(new Person("Owen", 9500, "male", "New York")); personList.add(new Person("Alisa", 7900, "female", "New York"));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;}// 省略了get和set，請自行添加}

3.1 遍歷/匹配（foreach/find/match）

Stream也是支持類似集合的遍歷和匹配元素的，只是Stream中的元素是以Optional類型存在的。Stream的遍歷、匹配非常簡單。

// import已省略，請自行添加，后面代碼亦是public class StreamTest {public static void main(String[] args) {List<Integer> list = Arrays.asList(7, 6, 9, 3, 8, 2, 1);// 遍歷輸出符合條件的元素list.stream().filter(x -> x > 6).forEach(System.out::println);// 匹配第一個Optional<Integer> findFirst = list.stream().filter(x -> x > 6).findFirst();// 匹配任意（適用于并行流）Optional<Integer> findAny = list.parallelStream().filter(x -> x > 6).findAny();// 是否包含符合特定條件的元素boolean anyMatch = list.stream().anyMatch(x -> x < 6);System.out.println("匹配第一個值：" + findFirst.get());System.out.println("匹配任意一個值：" + findAny.get());System.out.println("是否存在大于6的值：" + anyMatch);} }

3.2 篩選（filter）

篩選，是按照一定的規則校驗流中的元素，將符合條件的元素提取到新的流中的操作。

案例一：篩選出Integer集合中大于7的元素，并打印出來

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();stream.filter(x -> x > 7).forEach(System.out::println);} }

預期結果：

8 9

案例二：篩選員工中工資高于8000的人，并形成新的集合。形成新集合依賴collect（收集），后文有詳細介紹。

運行結果：

高于8000的員工姓名：[Tom, Anni, Owen]

3.3 聚合（max/min/count)

max、min、count這些字眼你一定不陌生，沒錯，在mysql中我們常用它們進行數據統計。Java stream中也引入了這些概念和用法，極大地方便了我們對集合、數組的數據統計工作。

案例一：獲取String集合中最長的元素。

public class StreamTest {public static void main(String[] args) {List<String> list = Arrays.asList("adnm", "admmt", "pot", "xbangd", "weoujgsd");Optional<String> max = list.stream().max(Comparator.comparing(String::length));System.out.println("最長的字符串：" + max.get());} }

輸出結果：

最長的字符串：weoujgsd

案例二：獲取Integer集合中的最大值。

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>() {@Overridepublic int compare(Integer o1, Integer o2) {return o1.compareTo(o2);}});System.out.println("自然排序的最大值：" + max.get());System.out.println("自定義排序的最大值：" + max2.get());} }

輸出結果：

自然排序的最大值：11 自定義排序的最大值：11

案例三：獲取員工工資最高的人。

輸出結果：

員工工資最大值：9500

案例四：計算Integer集合中大于6的元素的個數。

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);long count = list.stream().filter(x -> x > 6).count();System.out.println("list中大于6的元素個數：" + count);} }

輸出結果：

list中大于6的元素個數：4

3.4 映射(map/flatMap)

映射，可以將一個流的元素按照一定的映射規則映射到另一個流中。分為map和flatMap：

map：接收一個函數作為參數，該函數會被應用到每個元素上，并將其映射成一個新的元素。
flatMap：接收一個函數作為參數，將流中的每個值都換成另一個流，然后把所有流連接成一個流。

案例一：英文字符串數組的元素全部改為大寫。整數數組每個元素+3。

public class StreamTest {public static void main(String[] args) {String[] strArr = { "abcd", "bcdd", "defde", "fTr" };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("每個元素大寫：" + strList);System.out.println("每個元素+3：" + intListNew);} }

輸出結果：

每個元素大寫：[ABCD, BCDD, DEFDE, FTR] 每個元素+3：[4, 6, 8, 10, 12, 14]

案例二：將員工的薪資全部增加1000。

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<Person> personListNew = personList.stream().map(person -> {Person personNew = new Person(person.getName(), 0, 0, null, null);personNew.setSalary(person.getSalary() + 10000);return personNew;}).collect(Collectors.toList());System.out.println("一次改動前：" + personList.get(0).getName() + "-->" + personList.get(0).getSalary());System.out.println("一次改動后：" + personListNew.get(0).getName() + "-->" + personListNew.get(0).getSalary());// 改變原來員工集合的方式List<Person> personListNew2 = personList.stream().map(person -> {person.setSalary(person.getSalary() + 10000);return person;}).collect(Collectors.toList());System.out.println("二次改動前：" + personList.get(0).getName() + "-->" + personListNew.get(0).getSalary());System.out.println("二次改動后：" + personListNew2.get(0).getName() + "-->" + personListNew.get(0).getSalary());} }

輸出結果：

一次改動前：Tom–>8900 一次改動后：Tom–>18900 二次改動前：Tom–>18900 二次改動后：Tom–>18900

案例三：將兩個字符數組合并成一個新的字符數組。

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 -> {// 將每個元素轉換成一個streamString[] split = s.split(",");Stream<String> s2 = Arrays.stream(split);return s2;}).collect(Collectors.toList());System.out.println("處理前的集合：" + list);System.out.println("處理后的集合：" + listNew);} }

輸出結果：

處理前的集合：[m-k-l-a, 1-3-5] 處理后的集合：[m, k, l, a, 1, 3, 5]

3.5 歸約(reduce)

歸約，也稱縮減，顧名思義，是把一個流縮減成一個值，能實現對集合求和、求乘積和求最值操作。

案例一：求Integer集合的元素之和、乘積和最大值。

public class StreamTest {public static void main(String[] args) {List<Integer> list = Arrays.asList(1, 3, 2, 8, 11, 4);// 求和方式1Optional<Integer> sum = list.stream().reduce((x, y) -> x + y);// 求和方式2Optional<Integer> sum2 = list.stream().reduce(Integer::sum);// 求和方式3Integer sum3 = list.stream().reduce(0, Integer::sum);// 求乘積Optional<Integer> product = list.stream().reduce((x, y) -> x * y);// 求最大值方式1Optional<Integer> max = list.stream().reduce((x, y) -> x > y ? x : y);// 求最大值寫法2Integer max2 = list.stream().reduce(1, Integer::max);System.out.println("list求和：" + sum.get() + "," + sum2.get() + "," + sum3);System.out.println("list求積：" + product.get());System.out.println("list求和：" + max.get() + "," + max2);} }

輸出結果：

list求和：29,29,29 list求積：2112 list求和：11,11

案例二：求所有員工的工資之和和最高工資。

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"));// 求工資之和方式1：Optional<Integer> sumSalary = personList.stream().map(Person::getSalary).reduce(Integer::sum);// 求工資之和方式2：Integer sumSalary2 = personList.stream().reduce(0, (sum, p) -> sum += p.getSalary(),(sum1, sum2) -> sum1 + sum2);// 求工資之和方式3：Integer sumSalary3 = personList.stream().reduce(0, (sum, p) -> sum += p.getSalary(), Integer::sum);// 求最高工資方式1：Integer maxSalary = personList.stream().reduce(0, (max, p) -> max > p.getSalary() ? max : p.getSalary(),Integer::max);// 求最高工資方式2：Integer maxSalary2 = personList.stream().reduce(0, (max, p) -> max > p.getSalary() ? max : p.getSalary(),(max1, max2) -> max1 > max2 ? max1 : max2);System.out.println("工資之和：" + sumSalary.get() + "," + sumSalary2 + "," + sumSalary3);System.out.println("最高工資：" + maxSalary + "," + maxSalary2);} }

輸出結果：

工資之和：49300,49300,49300 最高工資：9500,9500

3.6 收集(collect)

collect，收集，可以說是內容最繁多、功能最豐富的部分了。從字面上去理解，就是把一個流收集起來，最終可以是收集成一個值也可以收集成一個新的集合。

collect主要依賴java.util.stream.Collectors類內置的靜態方法。

3.6.1 歸集(toList/toSet/toMap)
因為流不存儲數據，那么在流中的數據完成處理后，需要將流中的數據重新歸集到新的集合里。toList、toSet和toMap比較常用，另外還有toCollection、toConcurrentMap等復雜一些的用法。

下面用一個案例演示toList、toSet和toMap：

public class StreamTest {public static void main(String[] args) {List<Integer> list = Arrays.asList(1, 6, 3, 4, 6, 7, 9, 6, 20);List<Integer> listNew = list.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());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"));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);} }

運行結果：

toList：[6, 4, 6, 6, 20] toSet：[4, 20, 6] toMap：{Tom=mutest.Person@5fd0d5ae, Anni=mutest.Person@2d98a335}

3.6.2 統計(count/averaging)

Collectors提供了一系列用于數據統計的靜態方法：

計數：count

平均值：averagingInt、averagingLong、averagingDouble

最值：maxBy、minBy

求和：summingInt、summingLong、summingDouble

統計以上所有：summarizingInt、summarizingLong、summarizingDouble

案例：統計員工人數、平均工資、工資總額、最高工資。

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"));// 求總數Long count = personList.stream().collect(Collectors.counting());// 求平均工資Double average = personList.stream().collect(Collectors.averagingDouble(Person::getSalary));// 求最高工資Optional<Integer> max = personList.stream().map(Person::getSalary).collect(Collectors.maxBy(Integer::compare));// 求工資之和Integer sum = personList.stream().collect(Collectors.summingInt(Person::getSalary));// 一次性統計所有信息DoubleSummaryStatistics collect = personList.stream().collect(Collectors.summarizingDouble(Person::getSalary));System.out.println("員工總數：" + count);System.out.println("員工平均工資：" + average);System.out.println("員工工資總和：" + sum);System.out.println("員工工資所有統計：" + collect);} }

運行結果：

員工總數：3 員工平均工資：7900.0 員工工資總和：23700 員工工資所有統計：DoubleSummaryStatistics{count=3, sum=23700.000000,min=7000.000000, average=7900.000000, max=8900.000000}

3.6.3 分組(partitioningBy/groupingBy)

分區：將stream按條件分為兩個Map，比如員工按薪資是否高于8000分為兩部分。

分組：將集合分為多個Map，比如員工按性別分組。有單級分組和多級分組。

案例：將員工按薪資是否高于8000分為兩部分；將員工按性別和地區分組

public class StreamTest {public static void main(String[] args) {List<Person> personList = new ArrayList<Person>();personList.add(new Person("Tom", 8900, "male", "New York"));personList.add(new Person("Jack", 7000, "male", "Washington"));personList.add(new Person("Lily", 7800, "female", "Washington"));personList.add(new Person("Anni", 8200, "female", "New York"));personList.add(new Person("Owen", 9500, "male", "New York"));personList.add(new Person("Alisa", 7900, "female", "New York"));// 將員工按薪資是否高于8000分組Map<Boolean, List<Person>> part = personList.stream().collect(Collectors.partitioningBy(x -> x.getSalary() > 8000));// 將員工按性別分組Map<String, List<Person>> group = personList.stream().collect(Collectors.groupingBy(Person::getSex));// 將員工先按性別分組，再按地區分組Map<String, Map<String, List<Person>>> group2 = personList.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getArea)));System.out.println("員工按薪資是否大于8000分組情況：" + part);System.out.println("員工按性別分組情況：" + group);System.out.println("員工按性別、地區：" + group2);} }

輸出結果：

員工按薪資是否大于8000分組情況：{false=[mutest.Person@2d98a335, mutest.Person@16b98e56, mutest.Person@7ef20235], true=[mutest.Person@27d6c5e0, mutest.Person@4f3f5b24, mutest.Person@15aeb7ab]} 員工按性別分組情況：{female=[mutest.Person@16b98e56, mutest.Person@4f3f5b24, mutest.Person@7ef20235], male=[mutest.Person@27d6c5e0, mutest.Person@2d98a335, mutest.Person@15aeb7ab]} 員工按性別、地區：{female={New York=[mutest.Person@4f3f5b24, mutest.Person@7ef20235], Washington=[mutest.Person@16b98e56]}, male={New York=[mutest.Person@27d6c5e0, mutest.Person@15aeb7ab], Washington=[mutest.Person@2d98a335]}}

3.6.4 接合(joining)

joining可以將stream中的元素用特定的連接符（沒有的話，則直接連接）連接成一個字符串。

運行結果：

所有員工的姓名：Tom,Jack,Lily 拼接后的字符串：A-B-C

3.6.5 歸約(reducing)

Collectors類提供的reducing方法，相比于stream本身的reduce方法，增加了對自定義歸約的支持。

運行結果：

員工扣稅薪資總和：8700 員工薪資總和：23700

3.7 排序(sorted)

sorted，中間操作。有兩種排序：

sorted()：自然排序，流中元素需實現Comparable接口

sorted(Comparator com)：Comparator排序器自定義排序

案例：將員工按工資由高到低（工資一樣則按年齡由大到小）排序

public class StreamTest {public static void main(String[] args) {List<Person> personList = new ArrayList<Person>();personList.add(new Person("Sherry", 9000, 24, "female", "New York"));personList.add(new Person("Tom", 8900, 22, "male", "Washington"));personList.add(new Person("Jack", 9000, 25, "male", "Washington"));personList.add(new Person("Lily", 8800, 26, "male", "New York"));personList.add(new Person("Alisa", 9000, 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).thenComparing(Person::getAge)).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 p2.getSalary() - p1.getSalary();}}).map(Person::getName).collect(Collectors.toList());System.out.println("按工資升序排序：" + newList);System.out.println("按工資降序排序：" + newList2);System.out.println("先按工資再按年齡升序排序：" + newList3);System.out.println("先按工資再按年齡自定義降序排序：" + newList4);} }

運行結果：

按工資自然排序：[Lily, Tom, Sherry, Jack, Alisa] 按工資降序排序：[Sherry, Jack, Alisa,Tom, Lily] 先按工資再按年齡自然排序：[Sherry, Jack, Alisa, Tom, Lily] 先按工資再按年齡自定義降序排序：[Alisa, Jack, Sherry, Tom, Lily]

3.8 提取/組合
流也可以進行合并、去重、限制、跳過等操作。

public class StreamTest {public static void main(String[] args) {String[] arr1 = { "a", "b", "c", "d" };String[] arr2 = { "d", "e", "f", "g" };Stream<String> stream1 = Stream.of(arr1);Stream<String> stream2 = Stream.of(arr2);// concat:合并兩個流 distinct：去重List<String> newList = Stream.concat(stream1, stream2).distinct().collect(Collectors.toList());// limit：限制從流中獲得前n個數據List<Integer> collect = Stream.iterate(1, x -> x + 2).limit(10).collect(Collectors.toList());// skip：跳過前n個數據List<Integer> collect2 = Stream.iterate(1, x -> x + 2).skip(1).limit(5).collect(Collectors.toList());System.out.println("流合并：" + newList);System.out.println("limit：" + collect);System.out.println("skip：" + collect2);} }

運行結果：

流合并：[a, b, c, d, e, f, g] limit：[1, 3, 5, 7, 9, 11, 13, 15, 17, 19] skip：[3, 5, 7, 9, 11]

4. 函數式編程Stream接口

Java 8之所以費這么大功夫引入函數式編程，原因有二：

代碼簡潔函數式編程寫出的代碼簡潔且意圖明確，使用stream接口讓你從此告別for循環。

多核友好，Java函數式編程使得編寫并行程序從未如此簡單，你需要的全部就是調用一下parallel()方法。

今天主要分享stream，也就是Java函數式編程的主角。對于Java 7來說stream完全是個陌生東西，stream并不是某種數據結構，它只是數據源的一種視圖。這里的數據源可以是一個數組，Java容器或I/O channel等。正因如此要得到一個stream通常不會手動創建，而是調用對應的工具方法，比如：

調用Collection.stream()或者Collection.parallelStream()方法
調用Arrays.stream(T[] array)方法

常見的stream接口繼承關系如圖：

stream接口繼承自BaseStream，其中IntStream, LongStream, DoubleStream對應三種基本類型（int, long, double，注意不是包裝類型），Stream對應所有剩余類型的stream視圖。為不同數據類型設置不同stream接口，可以

提高性能，
增加特定接口函數

你可能會奇怪為什么不把IntStream等設計成Stream的子接口？畢竟這接口中的方法名大部分是一樣的。答案是這些方法的名字雖然相同，但是返回類型不同，如果設計成父子接口關系，這些方法將不能共存，因為Java不允許只有返回類型不同的方法重載。

雖然大部分情況下stream是容器調用Collection.stream()方法得到的，但stream和collections有以下不同：

無存儲。stream不是一種數據結構，它只是某種數據源的一個視圖，數據源可以是一個數組，Java容器或I/O channel等。
為函數式編程而生。對stream的任何修改都不會修改背后的數據源，比如對stream執行過濾操作并不會刪除被過濾的元素，而是會產生一個不包含被過濾元素的新stream。
惰式執行。stream上的操作并不會立即執行，只有等到用戶真正需要結果的時候才會執行。
可消費性。stream只能被“消費”一次，一旦遍歷過就會失效，就像容器的迭代器那樣，想要再次遍歷必須重新生成。
對stream的操作分為為兩類，中間操作(intermediate operations)和結束操作(terminal operations)，二者特點是：

中間操作總是會惰式執行，調用中間操作只會生成一個標記了該操作的新stream，僅此而已。

結束操作會觸發實際計算，計算發生時會把所有中間操作積攢的操作以pipeline的方式執行，這樣可以減少迭代次數。計算完成之后stream就會失效。

如果你熟悉Apache Spark RDD，對stream的這個特點應該不陌生。

下表匯總了Stream接口的部分常見方法：

區分中間操作和結束操作最簡單的方法，就是看方法的返回值，返回值為stream的大都是中間操作，否則是結束操作。

5、stream方法結合函數式接口的使用

stream跟函數接口關系非常緊密，沒有函數接口stream就無法工作。回顧一下：函數接口是指內部只有一個抽象方法的接口。通常函數接口出現的地方都可以使用Lambda表達式，所以不必記憶函數接口的名字。

forEach()

我們對forEach()方法并不陌生，在Collection中我們已經見過。方法簽名為void forEach(Consumer<? super E> action)，作用是對容器中的每個元素執行action指定的動作，也就是對元素進行遍歷。

由于forEach()是結束方法，上述代碼會立即執行，輸出所有字符串。

filter()

函數原型為Stream filter(Predicate<? super T> predicate)，作用是返回一個只包含滿足predicate條件元素的Stream。

上述代碼將輸出為長度等于3的字符串you和too。注意，由于filter()是個中間操作，如果只調用filter()不會有實際計算，因此也不會輸出任何信息。

distinct()

函數原型為Stream distinct()，作用是返回一個去除重復元素之后的Stream。

sorted()

排序函數有兩個，一個是用自然順序排序，一個是使用自定義比較器排序，函數原型分別為Stream<T>　sorted()和Stream<T>　sorted(Comparator<? super T> comparator)。

上述代碼將輸出按照長度升序排序后的字符串，結果完全在預料之中。

map()

函數原型為 Stream map(Function<? super T,? extends R> mapper)，作用是返回一個對當前所有元素執行執行mapper之后的結果組成的Stream。直觀的說，就是對每個元素按照某種操作進行轉換，轉換前后Stream中元素的個數不會改變，但元素的類型取決于轉換之后的類型。

上述代碼將輸出原字符串的大寫形式。

flatMap()

函數原型為<R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper)，作用是對每個元素執行mapper指定的操作，并用所有mapper返回的Stream中的元素組成一個新的Stream作為最終返回結果。說起來太拗口，通俗的講flatMap()的作用就相當于把原stream中的所有元素都"攤平"之后組成的Stream，轉換前后元素的個數和類型都可能會改變。

上述代碼中，原來的stream中有兩個元素，分別是兩個List，執行flatMap()之后，將每個List都“攤平”成了一個個的數字，所以會新產生一個由5個數字組成的Stream。所以最終將輸出1~5這5個數字。
文章轉自

總結

以上是生活随笔為你收集整理的Java8 Stream 函数式接口的全部內容，希望文章能夠幫你解決所遇到的問題。

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

上一篇：互联网晚报 | 2月8日星期二 | 上
下一篇：探究Java常量本质及三种常量池（JVM