JDK 1.8新增的Stream，配合Lambda，给操作集合(Collection)提供了极大的便利。
那么什么是Stream？Stream将要处理的元素集合看作一种流，在流的过程中，借助Stream API对流中的元素进行操作，比如：筛选、排序、聚合等。
Stream可以由数组或集合创建，对流的操作分为两种：
中间操作，每次返回一个新的流，可以有多个。
终端操作，每个流只能进行一次终端操作，终端操作结束后流无法再次使用。终端操作会产生一个新的集合或值。
另外，Stream有几个特性：
stream不存储数据，而是按照特定的规则对数据进行计算，一般会输出结果。
stream不会改变数据源，通常情况下会产生一个新的集合或一个值。
stream具有延迟执行特性，只有调用终端操作时，中间操作才会执行。
Stream有三种创建方式
通过java.util.Collection.stream()方法用集合创建流
使用java.util.Arrays.stream(T[] array)方法用数组创建流
使用Stream的静态方法：of()、iterate()、generate()
Listlist = Arrays.asList("a", "b", "c");
// 创建一个顺序流
Streamstream = list.stream();
// 创建一个并行流
StreamparallelStream = list.parallelStream(); 串行流：适合存在线程安全问题、阻塞任务、重量级任务，以及需要使用同一事务的逻辑。
并行流：适合没有线程安全问题、较单纯的数据处理任务。
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); 输出结果：
0 3 6 9
0.6796156909271994
0.1914314208854283
0.8116932592396652stream和parallelStream的简单区分：stream是顺序流，由主线程按顺序对流执行操作，而parallelStream是并行流，内部以多线程并行执行的方式对流进行操作，但前提是流中的数据处理没有顺序要求。例如：筛选集合中的奇数，两者的处理不同之处：如果流中的数据量足够大，并行流可以加快处速度。
除了直接创建并行流，还可以通过parallel()把顺序流转换成并行流：
OptionalfindFirst = list.stream().parallel().filter(x ->x >6).findFirst(); 关于更多的Parallel Stream，请参考：Java Parallel Stream和Java Stream之Parallel Streams编程指南
2.2 中间操作 2.2.1 筛选与切片filter(Predicate)：筛选流中某些元素
limit(long val)：截断流，取流中前val个元素
skip(n)：跳过n元素，配合limit(n)可实现分页
distinct()：通过流所生成元素的equals和hashCode去重
map(Function f)：接收流中元素，并且将其映射成为新元素，例如：从student对象中取name属性
flatMap(Function f)：将所有流中的元素并到一起连接成一个流
peek(Consumer c)：获取流中元素，操作流中元素，与foreach不同的是不会截断流，可继续操作。
使用场景：当遍历完数组后还有后续操作时或list数组转stream时，不适合在用Iterable的foreach循环，这个时候peek就派上用场了。2.2.4 排序
sorted()/sorted(Comparator)：产生一个新流，按照自然顺序/比较器规则排序
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)：当流中每个元素都符合该断言时才返回true，否则返回false
noneMatch(Predicate)：当流中每个元素都不符合该断言时才返回true，否则返回false
anyMatch(Predicate)：只要流中有一个元素满足该断言则返回true，否则返回false
寻找元素
findFirst()：返回流中第一个元素
findAny()：返回流中的任意元素
计数和极值
count()：返回流中元素的总个数
max()：返回流中元素大值
min()：返回流中元素最小值
Optional reduce(BinaryOperator accumulator)：第一次执行时，accumulator函数的第一个参数为流中的第一个元素，第二个参数为流中元素的第二个元素；第二次执行时，第一个参数为第一次函数执行的结果，第二个参数为流中的第三个元素；依次类推。
T reduce(T identity, BinaryOperator accumulator)：流程跟上面一样，只是第一次执行时，accumulator函数的第一个参数为identity，而第二个参数为流中的第一个元素。
U reduce(U identity, BiFunction
collect：接收一个Collector实例，将流中元素收集成另外一个数据结构。
Collector
Supplier supplier()：创建一个结果容器A
BiConsumer accumulator()：消费型接口，第一个参数为容器A，第二个参数为流中元素T
BinaryOperator combiner()：函数接口，该参数的作用跟上一个方法(reduce)中的combiner参数一样，将并行流中各个子进程的运行结果(accumulator函数操作后的容器A)进行合并。
Function finisher()：函数式接口，参数为：容器A，返回类型为：collect方法最终想要的结果R。
Set characteristics()：返回一个不可变的Set集合，用来表明该Collector的特征。有以下三个特征：
CONCURRENT：表示此收集器支持并发。（官方文档还有其他描述，暂时没去探索，故不作过多翻译）
UNORDERED：表示该收集操作不会保留流中元素原有的顺序。
IDENTITY_FINISH：表示finisher参数只是标识而已，可忽略。
collect主要依赖java.util.stream.Collectors类内置的静态方法。Collectors具体方法如下：
归集
toList()：将元素收集到一个新的List。
toMap()：将元素收集到Map中，Map其键和值是将提供的映射函数应用于元素的结果。
toSet()：将元素收集到一个新的Set。
toCollection()：将元素Collection按遇到顺序收集到一个new中。
toConcurrentMap()：将元素收集到ConcurrentMap的并发对象，其键和值是将提供的映射函数应用于元素的结果。
toUnmodifiableList()：将元素收集到一个不可修改的List集合中。任何修改List集合的操作都将导致UnsupportedOperationException。
toUnmodifiableSet()：将元素收集到一个不可修改的Set集合中。任何修改Set集合的操作都将导致UnsupportedOperationException。
统计
counting()：返回计算元素数量，如果没有元素，则结果为0。
averagingDouble()：应用于元素的double值函数的算术平均值。如果没有元素，则结果为0。
averagingInt()：应用于元素的int值函数的算术平均值。
averagingLong()：应用于元素的long值函数的算术平均值。
summarizingDouble()：将生成double映射函数应用于每个元素，并返回结果值的汇总统计信息。
summarizingInt()：将生成int映射函数应用于每个元素，并返回结果值的汇总统计信息。
summarizingLong()：将生成long映射函数应用于每个元素，并返回结果值的汇总统计信息。
summingDouble()：应用于元素的double值函数的总和。
summingInt()：应用于元素的int值函数的总和。
summingLong()：应用于元素的long值函数的总和。
maxBy()：根据给定的比较器产生大元素。
minBy()：根据给定的比较器产生最小元素。
分组
groupingBy()：根据分类函数对元素进行分组，并返回结果Map。
groupingByConcurrent()：并发执行，根据分类函数对元素进行分组。
partitioningBy()：对元素进行分区Predicate，并将它们组织成Map
接合
joining()：按遇到顺序将元素连接成String。
归约
reducing()：在指定的BinaryOperator下执行其元素的缩减。
映射
mapping()：通过在累加之前对每个元素应用映射函数。
结果集处理
collectingAndThen()：调整Collector执行其它的结束转换。
在使用Stream之前，先理解一个概念：Optional，Optional类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。
案例使用的员工类，这是后面案例中使用的员工类：
//学生类
package StreamCain;
public class Student {
private String name;
private String sex;
private int age;
private double soux;
//无参数
public Student(){}
//有参数构造方法
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中的元素是以Optional类型存在的。Stream的遍历、匹配非常简单。
publicclassStreamTest {
publicstaticvoidmain(String[] args) {
Listlist = Arrays.asList(7, 6, 9, 3, 8, 2, 1);
// 匹配第一个
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("匹配第一个值：" + findFirst.get());
System.out.println("匹配任意一个值：" + findAny.get());
System.out.println("是否存在大于6的值：" + anyMatch);
}
} 运行结果：
匹配第一个值：7
匹配任意一个值：8
是否存在大于6的值：truelist.forEach()与list.stream().forEach()区别
list.forEach()使用增强for循环。list.stream().forEach()首先将集合转换为流，然后对集合的流进行迭代。最后调用ReferencePipeline类的forEach方法。
publicvoidforEach(Consumeraction) {
if (!isParallel()) {
sourceStageSpliterator().forEachRemaining(action);
} else {
super.forEach(action);
}
}forEachRemaining方法对集合中剩余的元素进行操作，也就是说只遍历一次集合元素。
当一边遍历一边删除的时候，forEach能够快速失败，而stream().forEach()只有等到数组遍历完之后才会抛异常。
筛选，是按照一定的规则校验流中的元素，将符合条件的元素提取到新的流中的操作。
案例一：筛选出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);
}
} 预期结果：
8 9max、min、count这些字眼你一定不陌生，没错，在mysql中我们常用它们进行数据统计。Java stream中也引入了这些概念和用法，极大地方便了我们对集合、数组的数据统计工作。
案例一：获取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());
}
} 输出结果：
最长的字符串：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());
}
} 输出结果：
自然排序的大值：11
自定义排序的大值：11案例三：获取学生年龄最高的人。
Optionalmax = student.stream().max(Comparator.comparingInt(Student::getAge));
System.out.println(max.get().getAge());//56 案例四：计算Integer集合中大于6的元素的个数。
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的元素个数：" + count);
}
} 输出结果：
list中大于6的元素个数：4映射，可以将一个流的元素按照一定的映射规则映射到另一个流中。分为map和flatMap：
map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
案例一：英文字符串数组的元素全部改为大写。整数数组每个元素加3。
publicclassStreamTest {
publicstaticvoidmain(String[] args) {
String[] strArr = {"abcd", "bcdd", "defde", "fTr"};
// 数组元素转大写
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("每个元素大写：" + strList);
System.out.println("每个元素 + 3：" + intListNew);
}
} 输出结果：
每个元素大写：[ABCD, BCDD, DEFDE, FTR]
每个元素 + 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());
}
} 输出结果：
一次改动前：Tom–>8900
一次改动后：Tom–>18900
二次改动前：Tom–>18900
二次改动后：Tom–>18900案例三：将两个字符数组合并成一个新的字符数组。
publicclassStreamTest {
publicstaticvoidmain(String[] args) {
Listlist = Arrays.asList("m, k, l, a", "1, 3, 5, 7");
ListlistNew = list.stream().flatMap(s ->{
// 将每个元素转换成一个stream
String[] split = s.split(",");
Streams2 = Arrays.stream(split);
return s2;
}).collect(Collectors.toList());
System.out.println("处理前的集合：" + list);
System.out.println("处理后的集合：" + listNew);
}
} 输出结果：
处理前的集合：[m-k-l-a, 1-3-5-7]
处理后的集合：[m, k, l, a, 1, 3, 5, 7]归约，也称缩减，顾名思义，是把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作。
案例一：求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);
}
} 输出结果：
list求和：29,29,29
list求积：2112
list求和：11,11案例二：求所有学生的工资之和
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(收集)，可以说是内容最繁多、功能最丰富的部分了。从字面上去理解，就是把一个流收集起来，最终可以是收集成一个值也可以收集成一个新的集合。collect主要依赖java.util.stream.Collectors类内置的静态方法。
3.6.1 归集(toList/toSet/toMap)因为流不存储数据，那么在流中的数据完成处理后，需要将流中的数据重新归集到新的集合里。toList、toSet和toMap比较常用，另外还有toCollection、toConcurrentMap等复杂一些的用法。
下面用一个案例演示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());//转list
Setset = objects.stream().collect(Collectors.toSet());//转set
String joining = objects.stream().collect(Collectors.joining(","));//拼接
ArrayListnewList= objects.stream().collect(Collectors.toCollection(ArrayList::new));//不是转为了list或set，而是转为了指定的集合
System.out.println("list的结果为："+list);
System.out.println("set的结果为："+set);//唯一性
System.out.println("joining的结果为："+joining);
System.out.println(newList); 运行结果：
list的结果为：[i, 123, aa, vv, vv, you]
set的结果为：[aa, vv, 123, i, you]
joining的结果为：i,123,aa,vv,vv,you
[i, 123, aa, vv, vv, you]Collectors提供了一系列用于数据统计的静态方法：
计数：count
平均值：averagingInt、averagingLong、averagingDouble
最值：maxBy、minBy
求和：summingInt、summingLong、summingDouble
统计以上所有：summarizingInt、summarizingLong、summarizingDouble
案例：统计学生人数、平均工资、年龄总合、最高工资。
Long count = student.stream().collect(Collectors.counting());//总数
Double aveng = student.stream().collect(Collectors.averagingDouble(Student::getSoux));//平均数
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中的元素用特定的连接符（没有的话，则直接连接）连接成一个字符串。
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()：自然排序，流中元素需实现Comparable接口
sorted(Comparator com)：Comparator排序器自定义排序
案例：将员工按工资由高到低（工资一样则按年龄由大到小）排序
// 按工资升序排序（自然排序)
Listcollect = student.stream().sorted(Comparator.comparing(Student::getSoux)).map(Student::getName).collect(Collectors.toList());
System.out.println(collect); Streampeek(Consumeraction)Streammap(Functionmapper); peek接收一个Consumer，而map接收一个Function。
map：用于对流中的每个元素进行映射处理，然后再形成新的流；
peek：用于debug调试流中间结果，不能形成新的流，但能修改引用类型字段的值；
Consumer是没有返回值的，它只是对Stream中的元素进行某些操作，但是操作之后的数据并不返回到Stream中，所以Stream中的元素还是原来的元素。
而Function是有返回值的，这意味着对于Stream的元素的所有操作都会作为新的结果返回到Stream中。
这就是为什么peek String不会发生变化而peek Object会发送变化的原因。
4.2 peek和foreach区别peek：会继续返回Stream对象
forEach：返回void，结束Stream操作。
你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧
