JDK 1.8新增的Stream，配合Lambda，給操作集合(Collection)提供了極大的便利。
那么什么是Stream？Stream將要處理的元素集合看作一種流，在流的過程中，借助Stream API對流中的元素進(jìn)行操作，比如：篩選、排序、聚合等。
Stream可以由數(shù)組或集合創(chuàng)建，對流的操作分為兩種：
中間操作，每次返回一個(gè)新的流，可以有多個(gè)。
終端操作，每個(gè)流只能進(jìn)行一次終端操作，終端操作結(jié)束后流無法再次使用。終端操作會產(chǎn)生一個(gè)新的集合或值。
另外，Stream有幾個(gè)特性：
stream不存儲數(shù)據(jù)，而是按照特定的規(guī)則對數(shù)據(jù)進(jìn)行計(jì)算，一般會輸出結(jié)果。
stream不會改變數(shù)據(jù)源，通常情況下會產(chǎn)生一個(gè)新的集合或一個(gè)值。
stream具有延遲執(zhí)行特性，只有調(diào)用終端操作時(shí)，中間操作才會執(zhí)行。
Stream有三種創(chuàng)建方式
通過java.util.Collection.stream()方法用集合創(chuàng)建流
使用java.util.Arrays.stream(T[] array)方法用數(shù)組創(chuàng)建流
使用Stream的靜態(tài)方法：of()、iterate()、generate()
重慶分公司
重慶分公司
Listlist = Arrays.asList("a", "b", "c");
// 創(chuàng)建一個(gè)順序流
Streamstream = list.stream();
// 創(chuàng)建一個(gè)并行流
StreamparallelStream = list.parallelStream(); 串行流：適合存在線程安全問題、阻塞任務(wù)、重量級任務(wù)，以及需要使用同一事務(wù)的邏輯。
并行流：適合沒有線程安全問題、較單純的數(shù)據(jù)處理任務(wù)。
int[] array = {1,3,5,6,8};
IntStreamstream= Arrays.stream(array);Streamstream = Stream.of(1, 2, 3, 4, 5, 6);
Streamstream2 = Stream.iterate(0, (x) ->x + 3).limit(4);
stream2.forEach(System.out::println);
Streamstream3 = Stream.generate(Math::random).limit(3);
stream3.forEach(System.out::println); 輸出結(jié)果：
0 3 6 9
0.6796156909271994
0.1914314208854283
0.8116932592396652stream和parallelStream的簡單區(qū)分：stream是順序流，由主線程按順序?qū)α鲌?zhí)行操作，而parallelStream是并行流，內(nèi)部以多線程并行執(zhí)行的方式對流進(jìn)行操作，但前提是流中的數(shù)據(jù)處理沒有順序要求。例如：篩選集合中的奇數(shù)，兩者的處理不同之處：如果流中的數(shù)據(jù)量足夠大，并行流可以加快處速度。
除了直接創(chuàng)建并行流，還可以通過parallel()把順序流轉(zhuǎn)換成并行流：
OptionalfindFirst = list.stream().parallel().filter(x ->x >6).findFirst(); 關(guān)于更多的Parallel Stream，請參考：Java Parallel Stream和Java Stream之Parallel Streams編程指南
2.2 中間操作 2.2.1 篩選與切片filter(Predicate)：篩選流中某些元素
limit(long val)：截?cái)嗔?，取流中前val個(gè)元素
skip(n)：跳過n元素，配合limit(n)可實(shí)現(xiàn)分頁
distinct()：通過流所生成元素的equals和hashCode去重
map(Function f)：接收流中元素，并且將其映射成為新元素，例如：從student對象中取name屬性
flatMap(Function f)：將所有流中的元素并到一起連接成一個(gè)流
peek(Consumer c)：獲取流中元素，操作流中元素，與foreach不同的是不會截?cái)嗔?，可繼續(xù)操作。
使用場景：當(dāng)遍歷完數(shù)組后還有后續(xù)操作時(shí)或list數(shù)組轉(zhuǎn)stream時(shí)，不適合在用Iterable的foreach循環(huán)，這個(gè)時(shí)候peek就派上用場了。2.2.4 排序
sorted()/sorted(Comparator)：產(chǎn)生一個(gè)新流，按照自然順序/比較器規(guī)則排序
ArrayListnumber = new ArrayList<>();
number.add(12);
number.add(121);
number.add(23);
number.add(45);
number.add(67);
number.add(67);
number.add(77);
number.add(98);
number.add(99);
number.add(67);
Streamdistinct = number.stream().filter(x ->x >50)//121,67,67,77,98，99,67
.skip(2)//67,77,98，99,67
.sorted()//67,67,77,98,99
.distinct()//67,77,98,99
.limit(3);//67,77,98
distinct.forEach(System.out::println); 匹配
allMatch(Predicate)：當(dāng)流中每個(gè)元素都符合該斷言時(shí)才返回true，否則返回false
noneMatch(Predicate)：當(dāng)流中每個(gè)元素都不符合該斷言時(shí)才返回true，否則返回false
anyMatch(Predicate)：只要流中有一個(gè)元素滿足該斷言則返回true，否則返回false
尋找元素
findFirst()：返回流中第一個(gè)元素
findAny()：返回流中的任意元素
計(jì)數(shù)和極值
count()：返回流中元素的總個(gè)數(shù)
max()：返回流中元素大值
min()：返回流中元素最小值
Optional reduce(BinaryOperator accumulator)：第一次執(zhí)行時(shí)，accumulator函數(shù)的第一個(gè)參數(shù)為流中的第一個(gè)元素，第二個(gè)參數(shù)為流中元素的第二個(gè)元素；第二次執(zhí)行時(shí)，第一個(gè)參數(shù)為第一次函數(shù)執(zhí)行的結(jié)果，第二個(gè)參數(shù)為流中的第三個(gè)元素；依次類推。
T reduce(T identity, BinaryOperator accumulator)：流程跟上面一樣，只是第一次執(zhí)行時(shí)，accumulator函數(shù)的第一個(gè)參數(shù)為identity，而第二個(gè)參數(shù)為流中的第一個(gè)元素。
U reduce(U identity, BiFunction
collect：接收一個(gè)Collector實(shí)例，將流中元素收集成另外一個(gè)數(shù)據(jù)結(jié)構(gòu)。
Collector
Supplier supplier()：創(chuàng)建一個(gè)結(jié)果容器A
BiConsumer accumulator()：消費(fèi)型接口，第一個(gè)參數(shù)為容器A，第二個(gè)參數(shù)為流中元素T
BinaryOperator combiner()：函數(shù)接口，該參數(shù)的作用跟上一個(gè)方法(reduce)中的combiner參數(shù)一樣，將并行流中各個(gè)子進(jìn)程的運(yùn)行結(jié)果(accumulator函數(shù)操作后的容器A)進(jìn)行合并。
Function finisher()：函數(shù)式接口，參數(shù)為：容器A，返回類型為：collect方法最終想要的結(jié)果R。
Set characteristics()：返回一個(gè)不可變的Set集合，用來表明該Collector的特征。有以下三個(gè)特征：
CONCURRENT：表示此收集器支持并發(fā)。（官方文檔還有其他描述，暫時(shí)沒去探索，故不作過多翻譯）
UNORDERED：表示該收集操作不會保留流中元素原有的順序。
IDENTITY_FINISH：表示finisher參數(shù)只是標(biāo)識而已，可忽略。
collect主要依賴java.util.stream.Collectors類內(nèi)置的靜態(tài)方法。Collectors具體方法如下：
歸集
toList()：將元素收集到一個(gè)新的List。
toMap()：將元素收集到Map中，Map其鍵和值是將提供的映射函數(shù)應(yīng)用于元素的結(jié)果。
toSet()：將元素收集到一個(gè)新的Set。
toCollection()：將元素Collection按遇到順序收集到一個(gè)new中。
toConcurrentMap()：將元素收集到ConcurrentMap的并發(fā)對象，其鍵和值是將提供的映射函數(shù)應(yīng)用于元素的結(jié)果。
toUnmodifiableList()：將元素收集到一個(gè)不可修改的List集合中。任何修改List集合的操作都將導(dǎo)致UnsupportedOperationException。
toUnmodifiableSet()：將元素收集到一個(gè)不可修改的Set集合中。任何修改Set集合的操作都將導(dǎo)致UnsupportedOperationException。
統(tǒng)計(jì)
counting()：返回計(jì)算元素?cái)?shù)量，如果沒有元素，則結(jié)果為0。
averagingDouble()：應(yīng)用于元素的double值函數(shù)的算術(shù)平均值。如果沒有元素，則結(jié)果為0。
averagingInt()：應(yīng)用于元素的int值函數(shù)的算術(shù)平均值。
averagingLong()：應(yīng)用于元素的long值函數(shù)的算術(shù)平均值。
summarizingDouble()：將生成double映射函數(shù)應(yīng)用于每個(gè)元素，并返回結(jié)果值的匯總統(tǒng)計(jì)信息。
summarizingInt()：將生成int映射函數(shù)應(yīng)用于每個(gè)元素，并返回結(jié)果值的匯總統(tǒng)計(jì)信息。
summarizingLong()：將生成long映射函數(shù)應(yīng)用于每個(gè)元素，并返回結(jié)果值的匯總統(tǒng)計(jì)信息。
summingDouble()：應(yīng)用于元素的double值函數(shù)的總和。
summingInt()：應(yīng)用于元素的int值函數(shù)的總和。
summingLong()：應(yīng)用于元素的long值函數(shù)的總和。
maxBy()：根據(jù)給定的比較器產(chǎn)生大元素。
minBy()：根據(jù)給定的比較器產(chǎn)生最小元素。
分組
groupingBy()：根據(jù)分類函數(shù)對元素進(jìn)行分組，并返回結(jié)果Map。
groupingByConcurrent()：并發(fā)執(zhí)行，根據(jù)分類函數(shù)對元素進(jìn)行分組。
partitioningBy()：對元素進(jìn)行分區(qū)Predicate，并將它們組織成Map
接合
joining()：按遇到順序?qū)⒃剡B接成String。
歸約
reducing()：在指定的BinaryOperator下執(zhí)行其元素的縮減。
映射
mapping()：通過在累加之前對每個(gè)元素應(yīng)用映射函數(shù)。
結(jié)果集處理
collectingAndThen()：調(diào)整Collector執(zhí)行其它的結(jié)束轉(zhuǎn)換。
在使用Stream之前，先理解一個(gè)概念：Optional，Optional類是一個(gè)可以為null的容器對象。如果值存在則isPresent()方法會返回true，調(diào)用get()方法會返回該對象。
案例使用的員工類，這是后面案例中使用的員工類：
//學(xué)生類
package StreamCain;
public class Student {
private String name;
private String sex;
private int age;
private double soux;
//無參數(shù)
public Student(){}
//有參數(shù)構(gòu)造方法
public Student(String name,String sex,int age,double soux){
this.name=name;
this.sex=sex;
this.age=age;
this.soux=soux;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getSoux() {
return soux;
}
public void setSoux(double soux) {
this.soux = soux;
}
}
//老師類
package StreamCain;
import java.util.ArrayList;
import java.util.IntSummaryStatistics;
import java.util.stream.Collectors;
public class Teacher {
public static void main(String[] args) {
Student cainfly = new Student("Cainfly", "男", 25, 198);
Student ss = new Student("ss", "女", 25, 176);
Student mm = new Student("mm", "男", 56, 156);
Student gg = new Student("gg", "女", 34, 136);
Student ff = new Student("ff", "女", 12, 98);
Student hh = new Student("hh", "男", 4, 77);
//將這些對象添加到集合中
ArrayListstudent = new ArrayList<>();
student.add(cainfly);
student.add(ss);
student.add(mm);
student.add(gg);
student.add(ff);
student.add(hh);
System.out.println(student);
Integer sunage = student.stream().collect(Collectors.summingInt(Student::getAge));
//::方法的引用
System.out.println(sunage);
}
} Stream也是支持類似集合的遍歷和匹配元素的，只是Stream中的元素是以O(shè)ptional類型存在的。Stream的遍歷、匹配非常簡單。
publicclassStreamTest {
publicstaticvoidmain(String[] args) {
Listlist = Arrays.asList(7, 6, 9, 3, 8, 2, 1);
// 匹配第一個(gè)
OptionalfindFirst = list.stream().filter(x ->x >6).findFirst();
// 匹配任意（適用于并行流）
OptionalfindAny = list.parallelStream().filter(x ->x >6).findAny();
// 是否包含符合特定條件的元素booleananyMatch= list.stream().anyMatch(x ->x >6);
System.out.println("匹配第一個(gè)值：" + findFirst.get());
System.out.println("匹配任意一個(gè)值：" + findAny.get());
System.out.println("是否存在大于6的值：" + anyMatch);
}
} 運(yùn)行結(jié)果：
匹配第一個(gè)值：7
匹配任意一個(gè)值：8
是否存在大于6的值：truelist.forEach()與list.stream().forEach()區(qū)別
list.forEach()使用增強(qiáng)for循環(huán)。list.stream().forEach()首先將集合轉(zhuǎn)換為流，然后對集合的流進(jìn)行迭代。最后調(diào)用ReferencePipeline類的forEach方法。
publicvoidforEach(Consumeraction) {
if (!isParallel()) {
sourceStageSpliterator().forEachRemaining(action);
} else {
super.forEach(action);
}
}forEachRemaining方法對集合中剩余的元素進(jìn)行操作，也就是說只遍歷一次集合元素。
當(dāng)一邊遍歷一邊刪除的時(shí)候，forEach能夠快速失敗，而stream().forEach()只有等到數(shù)組遍歷完之后才會拋異常。
篩選，是按照一定的規(guī)則校驗(yàn)流中的元素，將符合條件的元素提取到新的流中的操作。
案例一：篩選出Integer集合中大于7的元素，并打印出來
publicclassStreamTest {
publicstaticvoidmain(String[] args) {
Listlist = Arrays.asList(6, 7, 3, 8, 1, 2, 9);
Streamstream = list.stream();
stream.filter(x ->x >7).forEach(System.out::println);
}
} 預(yù)期結(jié)果：
8 9max、min、count這些字眼你一定不陌生，沒錯(cuò)，在mysql中我們常用它們進(jìn)行數(shù)據(jù)統(tǒng)計(jì)。Java stream中也引入了這些概念和用法，極大地方便了我們對集合、數(shù)組的數(shù)據(jù)統(tǒng)計(jì)工作。
案例一：獲取String集合中最長的元素。
publicclassStreamTest {
publicstaticvoidmain(String[] args) {
Listlist = Arrays.asList("adnm", "admmt", "pot", "xbangd", "weoujgsd");
// 比較
Optionalmax = list.stream().max(Comparator.comparing(String::length));
System.out.println("最長的字符串：" + max.get());
}
} 輸出結(jié)果：
最長的字符串：weoujgsd案例二：獲取Integer集合中的大值。
publicclassStreamTest {
publicstaticvoidmain(String[] args) {
Listlist = Arrays.asList(7, 6, 9, 4, 11, 6);
// 自然排序
Optionalmax = list.stream().max(Integer::compareTo);
// 自定義排序
Optionalmax2 = list.stream().max(newComparator() {
@Overridepublicintcompare(Integer o1, Integer o2) {
return o1.compareTo(o2);
}
});
System.out.println("自然排序的大值：" + max.get());
System.out.println("自定義排序的大值：" + max2.get());
}
} 輸出結(jié)果：
自然排序的大值：11
自定義排序的大值：11案例三：獲取學(xué)生年齡最高的人。
Optionalmax = student.stream().max(Comparator.comparingInt(Student::getAge));
System.out.println(max.get().getAge());//56 案例四：計(jì)算Integer集合中大于6的元素的個(gè)數(shù)。
publicclassStreamTest {
publicstaticvoidmain(String[] args) {
Listlist = Arrays.asList(7, 6, 4, 8, 2, 11, 9);
longcount= list.stream().filter(x ->x >6).count();
System.out.println("list中大于6的元素個(gè)數(shù)：" + count);
}
} 輸出結(jié)果：
list中大于6的元素個(gè)數(shù)：4映射，可以將一個(gè)流的元素按照一定的映射規(guī)則映射到另一個(gè)流中。分為map和flatMap：
map：接收一個(gè)函數(shù)作為參數(shù)，該函數(shù)會被應(yīng)用到每個(gè)元素上，并將其映射成一個(gè)新的元素。
flatMap：接收一個(gè)函數(shù)作為參數(shù)，將流中的每個(gè)值都換成另一個(gè)流，然后把所有流連接成一個(gè)流。
案例一：英文字符串?dāng)?shù)組的元素全部改為大寫。整數(shù)數(shù)組每個(gè)元素加3。
publicclassStreamTest {
publicstaticvoidmain(String[] args) {
String[] strArr = {"abcd", "bcdd", "defde", "fTr"};
// 數(shù)組元素轉(zhuǎn)大寫
ListstrList = Arrays.stream(strArr).map(String::toUpperCase)
.collect(Collectors.toList());
ListintList = Arrays.asList(1, 3, 5, 7, 9, 11);
// 元素加法
ListintListNew = intList.stream().map(x ->x + 3).collect(Collectors.toList());
System.out.println("每個(gè)元素大寫：" + strList);
System.out.println("每個(gè)元素 + 3：" + intListNew);
}
} 輸出結(jié)果：
每個(gè)元素大寫：[ABCD, BCDD, DEFDE, FTR]
每個(gè)元素 + 3：[4, 6, 8, 10, 12, 14]案例二：將員工的薪資全部增加1000。
publicclassStreamTest {
publicstaticvoidmain(String[] args) {
ListemployeeList = init();
// 不改變原來員工集合的方式
ListemployeeListNew = employeeList.stream().map(employee ->{
EmployeeemployeeNew=newEmployee(employee.getName(), 0, 0, null, null);
employeeNew.setSalary(employee.getSalary() + 10000);
return employeeNew;
}).collect(Collectors.toList());
System.out.println("一次改動前：" + employeeList.get(0).getName()
+ "-->" + employeeList.get(0).getSalary());
System.out.println("一次改動后：" + employeeListNew.get(0).getName()
+ "-->" + employeeListNew.get(0).getSalary());
// 改變原來員工集合的方式
ListemployeeListNew2 = employeeList.stream().map(employee ->{
employee.setSalary(employee.getSalary() + 10000);
return employee;
}).collect(Collectors.toList());
System.out.println("二次改動前：" + employeeList.get(0).getName()
+ "-->" + employeeListNew.get(0).getSalary());
System.out.println("二次改動后：" + employeeListNew2.get(0).getName()
+ "-->" + employeeListNew.get(0).getSalary());
}
} 輸出結(jié)果：
一次改動前：Tom–>8900
一次改動后：Tom–>18900
二次改動前：Tom–>18900
二次改動后：Tom–>18900案例三：將兩個(gè)字符數(shù)組合并成一個(gè)新的字符數(shù)組。
publicclassStreamTest {
publicstaticvoidmain(String[] args) {
Listlist = Arrays.asList("m, k, l, a", "1, 3, 5, 7");
ListlistNew = list.stream().flatMap(s ->{
// 將每個(gè)元素轉(zhuǎn)換成一個(gè)stream
String[] split = s.split(",");
Streams2 = Arrays.stream(split);
return s2;
}).collect(Collectors.toList());
System.out.println("處理前的集合：" + list);
System.out.println("處理后的集合：" + listNew);
}
} 輸出結(jié)果：
處理前的集合：[m-k-l-a, 1-3-5-7]
處理后的集合：[m, k, l, a, 1, 3, 5, 7]歸約，也稱縮減，顧名思義，是把一個(gè)流縮減成一個(gè)值，能實(shí)現(xiàn)對集合求和、求乘積和求最值操作。
案例一：求Integer集合的元素之和、乘積和大值。
publicclassStreamTest {
publicstaticvoidmain(String[] args) {
Listlist = Arrays.asList(1, 3, 2, 8, 11, 4);
// 求和方式1
Optionalsum = list.stream().reduce((x, y) ->x + y);
// 求和方式2
Optionalsum2 = list.stream().reduce(Integer::sum);
// 求和方式3Integersum3= list.stream().reduce(0, Integer::sum);
// 求乘積
Optionalproduct = list.stream().reduce((x, y) ->x * y);
// 求大值方式1
Optionalmax = list.stream().reduce((x, y) ->x >y ? x : y);
// 求大值寫法2Integermax2= 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);
}
} 輸出結(jié)果：
list求和：29,29,29
list求積：2112
list求和：11,11案例二：求所有學(xué)生的工資之和
Double reduce1 = student.stream().map(Student::getSoux).reduce(0.0, Double::sum);
Optionalreduce = student.stream().map(Student::getSoux).reduce(Double::sum);
System.out.println(reduce1);//841.0
System.out.println(reduce.get().doubleValue());//841.0 collect(收集)，可以說是內(nèi)容最繁多、功能最豐富的部分了。從字面上去理解，就是把一個(gè)流收集起來，最終可以是收集成一個(gè)值也可以收集成一個(gè)新的集合。collect主要依賴java.util.stream.Collectors類內(nèi)置的靜態(tài)方法。
3.6.1 歸集(toList/toSet/toMap)因?yàn)榱鞑淮鎯?shù)據(jù)，那么在流中的數(shù)據(jù)完成處理后，需要將流中的數(shù)據(jù)重新歸集到新的集合里。toList、toSet和toMap比較常用，另外還有toCollection、toConcurrentMap等復(fù)雜一些的用法。
下面用一個(gè)案例演示toList、toSet和toMap：
ArrayListobjects = new ArrayList<>();
objects.add("i");
objects.add("123");
objects.add("aa");
objects.add("vv");
objects.add("vv");
objects.add("you");
Listlist = objects.stream().collect(Collectors.toList());//轉(zhuǎn)list
Setset = objects.stream().collect(Collectors.toSet());//轉(zhuǎn)set
String joining = objects.stream().collect(Collectors.joining(","));//拼接
ArrayListnewList= objects.stream().collect(Collectors.toCollection(ArrayList::new));//不是轉(zhuǎn)為了list或set，而是轉(zhuǎn)為了指定的集合
System.out.println("list的結(jié)果為："+list);
System.out.println("set的結(jié)果為："+set);//唯一性
System.out.println("joining的結(jié)果為："+joining);
System.out.println(newList); 運(yùn)行結(jié)果：
list的結(jié)果為：[i, 123, aa, vv, vv, you]
set的結(jié)果為：[aa, vv, 123, i, you]
joining的結(jié)果為：i,123,aa,vv,vv,you
[i, 123, aa, vv, vv, you]Collectors提供了一系列用于數(shù)據(jù)統(tǒng)計(jì)的靜態(tài)方法：
計(jì)數(shù)：count
平均值：averagingInt、averagingLong、averagingDouble
最值：maxBy、minBy
求和：summingInt、summingLong、summingDouble
統(tǒng)計(jì)以上所有：summarizingInt、summarizingLong、summarizingDouble
案例：統(tǒng)計(jì)學(xué)生人數(shù)、平均工資、年齡總合、最高工資。
? Long count = student.stream().collect(Collectors.counting());//總數(shù)
Double aveng = student.stream().collect(Collectors.averagingDouble(Student::getSoux));//平均數(shù)
Integer age = student.stream().collect(Collectors.summingInt(Student::getAge));//年齡總和
Optionalmaxage = student.stream().map(Student::getAge).collect((Collectors.maxBy(Integer::compare)));//年齡的大值
Optionalmax = student.stream().max(Comparator.comparingInt(Student::getAge));//年齡的大值
System.out.println(count);//6
System.out.println(aveng);//140.16666666666666
System.out.println(age);//156
System.out.println(maxage.get().toString());//56
System.out.println(max.get().getAge());//56 joining可以將stream中的元素用特定的連接符（沒有的話，則直接連接）連接成一個(gè)字符串。
? String name = student.stream().map(Student::getName).collect(Collectors.joining(","));
System.out.println(name);//Cainfly,ss,mm,gg,ff,hh
Listlist = Arrays.asList("A", "B", "C");
Stringstring= list.stream().collect(Collectors.joining("-"));
System.out.println("拼接后的字符串：" + string);//A-B-C
}
} Collectors類提供的reducing方法，相比于stream本身的reduce方法，增加了對自定義歸約的支持。
? Double reduce1 = student.stream().map(Student::getSoux).reduce(0.0, Double::sum);
Optionalreduce = student.stream().map(Student::getSoux).reduce(Double::sum);
System.out.println(reduce1);//841.0
System.out.println(reduce.get().doubleValue());//841.0 sorted，中間操作。有兩種排序：
sorted()：自然排序，流中元素需實(shí)現(xiàn)Comparable接口
sorted(Comparator com)：Comparator排序器自定義排序
案例：將員工按工資由高到低（工資一樣則按年齡由大到?。┡判?/p>
// 按工資升序排序（自然排序)
Listcollect = student.stream().sorted(Comparator.comparing(Student::getSoux)).map(Student::getName).collect(Collectors.toList());
System.out.println(collect); Streampeek(Consumeraction)Streammap(Functionmapper); peek接收一個(gè)Consumer，而map接收一個(gè)Function。
map：用于對流中的每個(gè)元素進(jìn)行映射處理，然后再形成新的流；
peek：用于debug調(diào)試流中間結(jié)果，不能形成新的流，但能修改引用類型字段的值；
Consumer是沒有返回值的，它只是對Stream中的元素進(jìn)行某些操作，但是操作之后的數(shù)據(jù)并不返回到Stream中，所以Stream中的元素還是原來的元素。
而Function是有返回值的，這意味著對于Stream的元素的所有操作都會作為新的結(jié)果返回到Stream中。
這就是為什么peek String不會發(fā)生變化而peek Object會發(fā)送變化的原因。
4.2 peek和foreach區(qū)別peek：會繼續(xù)返回Stream對象
forEach：返回void，結(jié)束Stream操作。
你是否還在尋找穩(wěn)定的海外服務(wù)器提供商？創(chuàng)新互聯(lián)www.cdcxhl.cn海外機(jī)房具備T級流量清洗系統(tǒng)配攻擊溯源，準(zhǔn)確流量調(diào)度確保服務(wù)器高可用性，企業(yè)級服務(wù)器適合批量采購，新人活動首月15元起，快前往官網(wǎng)查看詳情吧
