在Java1.8之前還沒有stream流式算法的時候，我們要是在一個放有多個User對象的list集合中，將每個User對象的主鍵ID取出，組合成一個新的集合，首先想到的肯定是遍歷，如下：
List<Long> userIdList = new ArrayList<>();
for (User user: list) {
userIdList.add(user.id);
}
或者在1.8有了lambda表達式以后，我們會這樣寫：
List<Long> userIdList = new ArrayList<>(); list.forEach(user -> list.add(user.id));
在有了stream之后，我們還可以這樣寫：
List<Long> userIdList = list.stream().map(User::getId).collect(Collectors.toList());
一行代碼直接搞定，是不是很方便呢。那么接下來。我們就一起看一下stream這個流式算法的新特性吧。
由上面的例子可以看出，java8的流式處理極大的簡化了對於集合的操作，實際上不光是集合，包括數組、文件等，只要是可以轉換成流，我們都可以借助流式處理，類似於我們寫SQL語句一樣對其進行操作。java8通過內部迭代來實現對流的處理，一個流式處理可以分為三個部分：轉換成流、中間操作、終端操作。如下圖：
以集合為例，一個流式處理的操作我們首先需要調用stream()函數將其轉換成流，然后再調用相應的中間操作達到我們需要對集合進行的操作，比如篩選、轉換等，最后通過終端操作對前面的結果進行封裝，返回我們需要的形式。
這里我們先創建一個User實體類：
class User{
private Long id; //主鍵id
private String name; //姓名
private Integer age; //年齡
private String school; //學校
public User(Long id, String name, Integer age, String school) {
this.id = id;
this.name = name;
this.age = age;
this.school = school;
}
此處省略get、set方法。。。
初始化：
List<User> list = new ArrayList<User>(){
{
add(new User(1l,"張三",10, "清華大學"));
add(new User(2l,"李四",12, "清華大學"));
add(new User(3l,"王五",15, "清華大學"));
add(new User(4l,"趙六",12, "清華大學"));
add(new User(5l,"田七",25, "北京大學"));
add(new User(6l,"小明",16, "北京大學"));
add(new User(7l,"小紅",14, "北京大學"));
add(new User(8l,"小華",14, "浙江大學"));
add(new User(9l,"小麗",17, "浙江大學"));
add(new User(10l,"小何",10, "浙江大學"));
}
};
1. 過濾
1.1 filter
我們希望過濾賽選處所有學校是清華大學的user：
System.out.println("學校是清華大學的user");
List<User> userList1 = list.stream().filter(user -> "清華大學".equals(user.getSchool())).collect(Collectors.toList());
userList1.forEach(user -> System.out.print(user.name + '、'));
控制台輸出結果為：
學校是清華大學的user 張三、李四、王五、趙六、
1.2 distinct
去重，我們希望獲取所有user的年齡（年齡不重復）
System.out.println("所有user的年齡集合");
List<Integer> userAgeList = list.stream().map(User::getAge).distinct().collect(Collectors.toList());
System.out.println("userAgeList = " + userAgeList);
map在下面會講到，現在主要是看distinct的用法，輸出結果如下：
所有user的年齡集合 userAgeList = [10, 12, 15, 25, 16, 14, 17]
1.3 limit
返回前n個元素的流，當集合的長度小於n時，則返回所有集合。
如獲取年齡是偶數的前2名user：
System.out.println("年齡是偶數的前兩位user");
List<User> userList3 = list.stream().filter(user -> user.getAge() % 2 == 0).limit(2).collect(Collectors.toList());
userList3.forEach(user -> System.out.print(user.name + '、'));
輸出結果為：
年齡是偶數的前兩位user 張三、李四、
1.4 sorted
排序，如現在我想將所有user按照age從大到小排序：
System.out.println("按年齡從大到小排序");
List<User> userList4 = list.stream().sorted((s1,s2) -> s2.age - s1.age).collect(Collectors.toList());
userList4.forEach(user -> System.out.print(user.name + '、'));
輸出結果為：
按年齡從大到小排序 田七、小麗、小明、王五、小紅、小華、李四、趙六、張三、小何、
1.5 skip
跳過n個元素后再輸出
如輸出list集合跳過前兩個元素后的list
System.out.println("跳過前面兩個user的其他所有user");
List<User> userList5 = list.stream().skip(2).collect(Collectors.toList());
userList5.forEach(user -> System.out.print(user.name + '、'));
輸出結果為：
跳過前面兩個user的其他所有user 王五、趙六、田七、小明、小紅、小華、小麗、小何、
2 映射
2.1 map
就是講user這個幾個精簡為某個字段的集合
如我現在想知道學校是清華大學的所有學生的姓名：
System.out.println("學校是清華大學的user的名字");
List<String> userList6 = list.stream().filter(user -> "清華大學".equals(user.school)).map(User::getName).collect(Collectors.toList());
userList6.forEach(user -> System.out.print(user + '、'));
輸出結果如下：
學校是清華大學的user的名字 張三、李四、王五、趙六、
除了上面這類基礎的map，java8還提供了mapToDouble(ToDoubleFunction<? super T> mapper)，mapToInt(ToIntFunction<? super T> mapper)，mapToLong(ToLongFunction<? super T> mapper)，這些映射分別返回對應類型的流，java8為這些流設定了一些特殊的操作，比如查詢學校是清華大學的user的年齡總和：
System.out.println("學校是清華大學的user的年齡總和");
int userList7 = list.stream().filter(user -> "清華大學".equals(user.school)).mapToInt(User::getAge).sum();
System.out.println( "學校是清華大學的user的年齡總和為： "+userList7);
輸出結果為：
學校是清華大學的user的年齡總和 學校是清華大學的user的年齡總和為： 49
1.2 flatMap
flatMap與map的區別在於 flatMap是將一個流中的每個值都轉成一個個流，然后再將這些流扁平化成為一個流 。舉例說明，假設我們有一個字符串數組String[] strs = {"hello", "world"};，我們希望輸出構成這一數組的所有非重復字符，那么我們用map和flatMap 實現如下：
String[] strings = {"Hello", "World"};
List l11 = Arrays.stream(strings).map(str -> str.split("")).map(str2->Arrays.stream(str2)).distinct().collect(Collectors.toList());
List l2 = Arrays.asList(strings).stream().map(s -> s.split("")).flatMap(Arrays::stream).distinct().collect(Collectors.toList());
System.out.println(l11.toString());
System.out.println(l2.toString());
輸出結果如下：
[java.util.stream.ReferencePipeline$Head@4c203ea1, java.util.stream.ReferencePipeline$Head@27f674d] [H, e, l, o, W, r, d]
由上我們可以看到使用map並不能實現我們現在想要的結果，而flatMap是可以的。這是因為在執行map操作以后，我們得到是一個包含多個字符串（構成一個字符串的字符數組）的流，此時執行distinct操作是基於在這些字符串數組之間的對比，所以達不到我們希望的目的；flatMap將由map映射得到的Stream<String[]>，轉換成由各個字符串數組映射成的流Stream<String>，再將這些小的流扁平化成為一個由所有字符串構成的大流Steam<String>，從而能夠達到我們的目的。
3 查找
3.1 allMatch
用於檢測是否全部都滿足指定的參數行為，如果全部滿足則返回true，例如我們判斷是否所有的user年齡都大於9歲，實現如下：
System.out.println("判斷是否所有user的年齡都大於9歲");
Boolean b = list.stream().allMatch(user -> user.age >9);
System.out.println(b);
輸出結果為：
判斷是否所有user的年齡都大於9歲 true
3.2 anyMatch
anyMatch則是檢測是否存在一個或多個滿足指定的參數行為，如果滿足則返回true，例如判斷是否有user的年齡大於15歲，實現如下：
System.out.println("判斷是否有user的年齡是大於15歲");
Boolean bo = list.stream().anyMatch(user -> user.age >15);
System.out.println(bo);
輸出結果為：
判斷是否有user的年齡是大於15歲 true
3.3 noneMatch
noneMatch用於檢測是否不存在滿足指定行為的元素，如果不存在則返回true，例如判斷是否不存在年齡是15歲的user，實現如下：
System.out.println("判斷是否不存在年齡是15歲的user");
Boolean boo = list.stream().noneMatch(user -> user.age == 15);
System.out.println(boo);
輸出結果如下：
判斷是否不存在年齡是15歲的user false
3.4 findFirst
findFirst用於返回滿足條件的第一個元素，比如返回年齡大於12歲的user中的第一個，實現如下:
System.out.println("返回年齡大於12歲的user中的第一個");
Optional<User> first = list.stream().filter(u -> u.age > 10).findFirst();
User user = first.get();
System.out.println(user.toString());
輸出結果如下：
返回年齡大於12歲的user中的第一個
User{id=2, name='李四', age=12, school='清華大學'}
3.5 findAny
findAny相對於findFirst的區別在於，findAny不一定返回第一個，而是返回任意一個，比如返回年齡大於12歲的user中的任意一個：
System.out.println("返回年齡大於12歲的user中的任意一個");
Optional<User> anyOne = list.stream().filter(u -> u.age > 10).findAny();
User user2 = anyOne.get();
System.out.println(user2.toString());
輸出結果如下：
返回年齡大於12歲的user中的任意一個
User{id=2, name='李四', age=12, school='清華大學'}
4 歸約
4.1 reduce
現在我的目標不是返回一個新的集合，而是希望對經過參數化操作后的集合進行進一步的運算，那么我們可用對集合實施歸約操作。java8的流式處理提供了reduce方法來達到這一目的。
比如我現在要查出學校是清華大學的所有user的年齡之和：
//前面用到的方法
Integer ages = list.stream().filter(student -> "清華大學".equals(student.school)).mapToInt(User::getAge).sum();
System.out.println(ages);
System.out.println("歸約 - - 》 start ");
Integer ages2 = list.stream().filter(student -> "清華大學".equals(student.school)).map(User::getAge).reduce(0,(a,c)->a+c);
Integer ages3 = list.stream().filter(student -> "清華大學".equals(student.school)).map(User::getAge).reduce(0,Integer::sum);
Integer ages4 = list.stream().filter(student -> "清華大學".equals(student.school)).map(User::getAge).reduce(Integer::sum).get();
System.out.println(ages2);
System.out.println(ages3);
System.out.println(ages4);
System.out.println("歸約 - - 》 end ");
輸出結果為：
49
歸約 - - 》 start
49
49
49
歸約 - - 》 end
5 收集
前面利用collect(Collectors.toList())是一個簡單的收集操作，是對處理結果的封裝，對應的還有toSet、toMap，以滿足我們對於結果組織的需求。這些方法均來自於java.util.stream.Collectors，我們可以稱之為收集器。
收集器也提供了相應的歸約操作，但是與reduce在內部實現上是有區別的，收集器更加適用於可變容器上的歸約操作，這些收集器廣義上均基於Collectors.reducing()實現。
5.1 counting
計算個數
如我現在計算user的總人數，實現如下：
System.out.println("user的總人數");
long COUNT = list.stream().count();//簡化版本
long COUNT2 = list.stream().collect(Collectors.counting());//原始版本
System.out.println(COUNT);
System.out.println(COUNT2);
輸出結果為:
user的總人數 10 10
5.2 maxBy、minBy
計算最大值和最小值
如我現在計算user的年齡最大值和最小值：
System.out.println("user的年齡最大值和最小值");
Integer maxAge =list.stream().collect(Collectors.maxBy((s1, s2) -> s1.getAge() - s2.getAge())).get().age;
Integer maxAge2 = list.stream().collect(Collectors.maxBy(Comparator.comparing(User::getAge))).get().age;
Integer minAge = list.stream().collect(Collectors.minBy((S1,S2) -> S1.getAge()- S2.getAge())).get().age;
Integer minAge2 = list.stream().collect(Collectors.minBy(Comparator.comparing(User::getAge))).get().age;
System.out.println("maxAge = " + maxAge);
System.out.println("maxAge2 = " + maxAge2);
System.out.println("minAge = " + minAge);
System.out.println("minAge2 = " + minAge2);
輸出結果為：
user的年齡最大值 maxAge = 25 maxAge2 = 25 minAge = 10 minAge2 = 10
5.3 summingInt、summingLong、summingDouble
總和
如計算user的年齡總和：
System.out.println("user的年齡總和");
Integer sumAge =list.stream().collect(Collectors.summingInt(User::getAge));
System.out.println("sumAge = " + sumAge);
輸出結果為：
user的年齡總和 sumAge = 145
5.4 averageInt、averageLong、averageDouble
平均值
如計算user的年齡平均值：
System.out.println("user的年齡平均值");
double averageAge = list.stream().collect(Collectors.averagingDouble(User::getAge));
System.out.println("averageAge = " + averageAge);
輸出結果為：
user的年齡平均值 averageAge = 14.5
5.5 summarizingInt、summarizingLong、summarizingDouble
一次性查詢元素個數、總和、最大值、最小值和平均值
System.out.println("一次性得到元素個數、總和、均值、最大值、最小值");
long l1 = System.currentTimeMillis();
IntSummaryStatistics summaryStatistics = list.stream().collect(Collectors.summarizingInt(User::getAge));
long l111 = System.currentTimeMillis();
System.out.println("計算這5個值消耗時間為" + (l111-l1));
System.out.println("summaryStatistics = " + summaryStatistics);
輸出結果為：
一次性得到元素個數、總和、均值、最大值、最小值
計算這5個值消耗時間為3
summaryStatistics = IntSummaryStatistics{count=10, sum=145, min=10, average=14.500000, max=25}
5.6 joining
字符串拼接
如輸出所有user的名字，用“，”隔開
System.out.println("字符串拼接");
String names = list.stream().map(User::getName).collect(Collectors.joining(","));
System.out.println("names = " + names);
輸出結果為：
字符串拼接 names = 張三,李四,王五,趙六,田七,小明,小紅,小華,小麗,小何
5.7 groupingBy
分組
如將user根據學校分組、先按學校分再按年齡分、每個大學的user人數、每個大學不同年齡的人數：
System.out.println("分組");
Map<String, List<User>> collect1 = list.stream().collect(Collectors.groupingBy(User::getSchool));
Map<String, Map<Integer, Long>> collect2 = list.stream().collect(Collectors.groupingBy(User::getSchool, Collectors.groupingBy(User::getAge, Collectors.counting())));
Map<String, Map<Integer, Map<String, Long>>> collect4 = list.stream().collect(Collectors.groupingBy(User::getSchool, Collectors.groupingBy(User::getAge, Collectors.groupingBy(User::getName,Collectors.counting()))));
Map<String, Long> collect3 = list.stream().collect(Collectors.groupingBy(User::getSchool, Collectors.counting()));
System.out.println("collect1 = " + collect1);
System.out.println("collect2 = " + collect2);
System.out.println("collect3 = " + collect3);
System.out.println("collect4 = " + collect4);
輸出結果為：
分組
collect1 = {浙江大學=[User{id=8, name='小華', age=14, school='浙江大學'}, User{id=9, name='小麗', age=17, school='浙江大學'}, User{id=10, name='小何', age=10, school='浙江大學'}], 北京大學=[User{id=5, name='田七', age=25, school='北京大學'}, User{id=6, name='小明', age=16, school='北京大學'}, User{id=7, name='小紅', age=14, school='北京大學'}], 清華大學=[User{id=1, name='張三', age=10, school='清華大學'}, User{id=2, name='李四', age=12, school='清華大學'}, User{id=3, name='王五', age=15, school='清華大學'}, User{id=4, name='趙六', age=12, school='清華大學'}]}
collect2 = {浙江大學={17=1, 10=1, 14=1}, 北京大學={16=1, 25=1, 14=1}, 清華大學={10=1, 12=2, 15=1}}
collect3 = {浙江大學=3, 北京大學=3, 清華大學=4}
collect4 = {浙江大學={17={小麗=1}, 10={小何=1}, 14={小華=1}}, 北京大學={16={小明=1}, 25={田七=1}, 14={小紅=1}}, 清華大學={10={張三=1}, 12={李四=1, 趙六=1}, 15={王五=1}}}
5.8 partitioningBy
分區，分區可以看做是分組的一種特殊情況，在分區中key只有兩種情況：true或false，目的是將待分區集合按照條件一分為二，java8的流式處理利用ollectors.partitioningBy()方法實現分區。
如按照是否是清華大學的user將左右user分為兩個部分：
System.out.println("分區");
Map<Boolean, List<User>> collect5 = list.stream().collect(Collectors.partitioningBy(user1 -> "清華大學".equals(user1.school)));
System.out.println("collect5 = " + collect5);
輸出結果為：
分區
collect5 = {false=[User{id=5, name='田七', age=25, school='北京大學'}, User{id=6, name='小明', age=16, school='北京大學'}, User{id=7, name='小紅', age=14, school='北京大學'}, User{id=8, name='小華', age=14, school='浙江大學'}, User{id=9, name='小麗', age=17, school='浙江大學'}, User{id=10, name='小何', age=10, school='浙江大學'}], true=[User{id=1, name='張三', age=10, school='清華大學'}, User{id=2, name='李四', age=12, school='清華大學'}, User{id=3, name='王五', age=15, school='清華大學'}, User{id=4, name='趙六', age=12, school='清華大學'}]}
關於Java1.8新特性之stream暫時只說這些，希望對你能有所幫助，謝謝！
參考博客:https://blog.csdn.net/papima/article/details/81808445