Java8 Stream 函数式接口
生活随笔
收集整理的這篇文章主要介紹了
Java8 Stream 函数式接口
小編覺得挺不錯的,現在分享給大家,幫大家做個參考.
在這里插入圖片描述
先貼上幾個案例，水平高超的同學可以挑戰一下：
從員工集合中篩選出salary大于8000的員工，并放置到新的集合里。
統計員工的最高薪資、平均薪資、薪資之和。
將員工按薪資從高到低排序，同樣薪資者年齡小者在前。
將員工按性別分類，將員工按性別和地區分類，將員工按薪資是否高于8000分為兩部分。
用傳統的迭代處理也不是很難，但代碼就顯得冗余了，跟Stream相比高下立判。
1 Stream概述
Java 8 是一個非常成功的版本，這個版本新增的Stream，配合同版本出現的 Lambda ，給我們操作集合（Collection）提供了極大的便利。
那么什么是Stream？
Stream將要處理的元素集合看作一種流，在流的過程中，借助Stream API對流中的元素進行操作，比如：篩選、排序、聚合等。
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.8116932592396652stream和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的使用整得明明白白，只要跟著敲一遍代碼，就能很好地掌握。
在這里插入圖片描述
案例使用的員工類
這是后面案例中使用的員工類：
3.1 遍歷/匹配（foreach/find/match）
Stream也是支持類似集合的遍歷和匹配元素的，只是Stream中的元素是以Optional類型存在的。Stream的遍歷、匹配非常簡單。
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（收集），后文有詳細介紹。
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> fiterList = personList.stream().filter(x -> x.getSalary() > 8000).map(Person::getName).collect(Collectors.toList());System.out.print("高于8000的員工姓名：" + fiterList);} }運行結果：
高于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案例三：獲取員工工資最高的人。
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"));Optional<Person> max = personList.stream().max(Comparator.comparingInt(Person::getSalary));System.out.println("員工工資最大值：" + max.get().getSalary());} }輸出結果：
員工工資最大值：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的元素個數：43.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,95003.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提供了一系列用于數據統計的靜態方法：
案例：統計員工人數、平均工資、工資總額、最高工資。
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)
案例：將員工按薪資是否高于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中的元素用特定的連接符（沒有的話，則直接連接）連接成一個字符串。
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"));String names = personList.stream().map(p -> p.getName()).collect(Collectors.joining(","));System.out.println("所有員工的姓名：" + names);List<String> list = Arrays.asList("A", "B", "C");String string = list.stream().collect(Collectors.joining("-"));System.out.println("拼接后的字符串：" + string);} }運行結果：
所有員工的姓名：Tom,Jack,Lily 拼接后的字符串：A-B-C3.6.5 歸約(reducing)
Collectors類提供的reducing方法，相比于stream本身的reduce方法，增加了對自定義歸約的支持。
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"));// 每個員工減去起征點后的薪資之和（這個例子并不嚴謹，但一時沒想到好的例子）Integer sum = personList.stream().collect(Collectors.reducing(0, Person::getSalary, (i, j) -> (i + j - 5000)));System.out.println("員工扣稅薪資總和：" + sum);// stream的reduceOptional<Integer> sum2 = personList.stream().map(Person::getSalary).reduce(Integer::sum);System.out.println("員工薪資總和：" + sum2.get());} }運行結果：
員工扣稅薪資總和：8700 員工薪資總和：237003.7 排序(sorted)
sorted，中間操作。有兩種排序：
案例：將員工按工資由高到低（工資一樣則按年齡由大到小）排序
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 提取/組合
流也可以進行合并、去重、限制、跳過等操作。
運行結果：
流合并：[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，也就是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)，二者特點是：
如果你熟悉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