推荐学习：《java视频教程》
一、概述java 8 是一个非常成功的版本，这个版本新增的stream，配合同版本出现的lambda ，给我们操作集合（collection）提供了极大的便利。stream流是jdk8新增的成员，允许以声明性方式处理数据集合，可以把stream流看作是遍历数据集合的一个高级迭代器。stream 是 java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找/筛选/过滤、排序、聚合和映射数据等操作。使用stream api 对集合数据进行操作，就类似于使用 sql 执行的数据库查询。也可以使用 stream api 来并行执行操作。简而言之，stream api 提供了一种高效且易于使用的处理数据的方式。
1、使用流的好处代码以声明性方式书写，说明想要完成什么，而不是说明如何完成一个操作。
可以把几个基础操作连接起来，来表达复杂的数据处理的流水线，同时保持代码清晰可读。
2、流是什么?从支持数据处理操作的源生成元素序列.数据源可以是集合,数组或io资源。
从操作角度来看,流与集合是不同的. 流不存储数据值; 流的目的是处理数据,它是关于算法与计算的。
如果把集合作为流的数据源,创建流时不会导致数据流动; 如果流的终止操作需要值时,流会从集合中获取值; 流只使用一次。
流中心思想是延迟计算,流直到需要时才计算值。
stream可以由数组或集合创建，对流的操作分为两种：
中间操作，每次返回一个新的流，可以有多个。
终端操作，每个流只能进行一次终端操作，终端操作结束后流无法再次使用。终端操作会产生一个新的集合或值。
特性：
不是数据结构，不会保存数据。
不会修改原来的数据源，它会将操作后的数据保存到另外一个对象中。（保留意见：毕竟peek方法可以修改流中元素）
惰性求值，流在中间处理过程中，只是对操作进行了记录，并不会立即执行，需要等到执行终止操作的时候才会进行实际的计算。
二、分类
无状态：指元素的处理不受之前元素的影响；
有状态：指该操作只有拿到所有元素之后才能继续下去。
非短路操作：指必须处理所有元素才能得到最终结果；
短路操作：指遇到某些符合条件的元素就可以得到最终结果，如 a || b，只要a为true，则无需判断b的结果。
三、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 90.67961569092719940.19143142088542830.8116932592396652
stream和 parallelstream的简单区分：stream是顺序流，由主线程按顺序对流执行操作，而 parallelstream是并行流，内部以多线程并行执行的方式对流进行操作，但前提是流中的数据处理没有顺序要求。例如筛选集合中的奇数，两者的处理不同之处：
如果流中的数据量足够大，并行流可以加快处速度。
除了直接创建并行流，还可以通过 parallel()把顺序流转换成并行流：
optional<integer> findfirst = list.stream().parallel().filter(x->x>6).findfirst();
四、stream api简介
先贴上几个案例，水平高超的同学可以挑战一下：从员工集合中筛选出salary大于8000的员工，并放置到新的集合里。统计员工的最高薪资、平均薪资、薪资之和。将员工按薪资从高到低排序，同样薪资者年龄小者在前。将员工按性别分类，将员工按性别和地区分类，将员工按薪资是否高于8000分为两部分。用传统的迭代处理也不是很难，但代码就显得冗余了，跟stream相比高下立判。
前提：员工类
static list<person> personlist = new arraylist<person>();private static void initperson() { personlist.add(new person(张三, 8, 3000)); personlist.add(new person(李四, 18, 5000)); personlist.add(new person(王五, 28, 7000)); personlist.add(new person(孙六, 38, 9000));}
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 = 18) { * list.add(person); * } * } */private static void filter01() { initperson(); list<person> collect = personlist.stream().filter(x -> x.getage()>=18).collect(collectors.tolist()); system.out.println(collect);}
（2）自定义条件匹配
3、聚合max、min、count
（1）获取string集合中最长的元素
/** * 获取string集合中最长的元素 * @思路 * list<string> list = arrays.aslist(zhangsan, lisi, wangwu, sunliu); * string max = ; * int length = 0; * int templength = 0; * for(string str : list) { * templength = str.length(); * if(templength > length) { * length = str.length(); * max = str; * } * } * @return zhangsan */private static void test02() { list<string> list = arrays.aslist(zhangsan, lisi, wangwu, sunliu); comparator<? super string> comparator = comparator.comparing(string::length); optional<string> max = list.stream().max(comparator); system.out.println(max);}
（2）获取integer集合中的最大值
//获取integer集合中的最大值private static void test05() { list<integer> list = arrays.aslist(1, 17, 27, 7); optional<integer> max = list.stream().max(integer::compareto); // 自定义排序 optional<integer> max2 = list.stream().max(new comparator<integer>() { @override public int compare(integer o1, integer o2) { return o1.compareto(o2); } }); system.out.println(max2);}
//获取员工中年龄最大的人private static void test06() { initperson(); comparator<? super person> comparator = comparator.comparingint(person::getage); optional<person> max = personlist.stream().max(comparator); system.out.println(max);}
（3）获取员工中年龄最大的人
（4）计算integer集合中大于10的元素的个数
4、map与flatmapmap：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
flatmap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
（1）字符串大写
（2）整数数组每个元素+3
/** * 整数数组每个元素+3 * @思路 * list<integer> list = arrays.aslist(1, 17, 27, 7); list<integer> list2 = new arraylist<integer>(); for(integer num : list) { list2.add(num + 3); } @return [4, 20, 30, 10] */private static void test09() { list<integer> list = arrays.aslist(1, 17, 27, 7); list<integer> collect = list.stream().map(x -> x + 3).collect(collectors.tolist()); system.out.println(collect);}
（3）公司效益好，每人涨2000
/** * 公司效益好，每人涨2000 * */private static void test10() { initperson(); list<person> collect = personlist.stream().map(x -> { x.setage(x.getsalary()+2000); return x; }).collect(collectors.tolist()); system.out.println(collect);}
（4）将两个字符数组合并成一个新的字符数组
/** * 将两个字符数组合并成一个新的字符数组 * */private static void test11() { string[] arr = {z, h, a, n, g, s, a, n}; list<string> list = arrays.aslist(arr); system.out.println(list); list<string> collect = list.stream().flatmap(x -> { string[] array = x.split(,); stream<string> stream = arrays.stream(array); return stream; }).collect(collectors.tolist()); system.out.println(collect);}
（5）将两个字符数组合并成一个新的字符数组
/** * 将两个字符数组合并成一个新的字符数组 * @return [z, h, a, n, g, s, a, n] */private static void test11() { string[] arr = {z, h, a, n, g, s, a, n}; list<string> list = arrays.aslist(arr); list<string> collect = list.stream().flatmap(x -> { string[] array = x.split(,); stream<string> stream = arrays.stream(array); return stream; }).collect(collectors.tolist()); system.out.println(collect);}
5、规约reduce归约，也称缩减，顾名思义，是把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作。
（1）求integer集合的元素之和、乘积和最大值
/** * 求integer集合的元素之和、乘积和最大值 * */private static void test13() { list<integer> list = arrays.aslist(1, 2, 3, 4); //求和 optional<integer> reduce = list.stream().reduce((x,y) -> x+ y); system.out.println(求和:+reduce); //求积 optional<integer> reduce2 = list.stream().reduce((x,y) -> x * y); system.out.println(求积:+reduce2); //求最大值 optional<integer> reduce3 = list.stream().reduce((x,y) -> x>y?x:y); system.out.println(求最大值:+reduce3);}
（2）求所有员工的工资之和和最高工资
/* * 求所有员工的工资之和和最高工资 */private static void test14() { initperson(); optional<integer> reduce = personlist.stream().map(person :: getsalary).reduce(integer::sum); optional<integer> reduce2 = personlist.stream().map(person :: getsalary).reduce(integer::max); system.out.println(工资之和:+reduce); system.out.println(最高工资:+reduce2);}
6、收集（tolist、toset、tomap）取出大于18岁的员工转为map
/** * 取出大于18岁的员工转为map * */private static void test15() { initperson(); map<string, person> collect = personlist.stream().filter(x -> x.getage() > 18).collect(collectors.tomap(person::getname, y -> y)); system.out.println(collect);}
7、collectcollectors提供了一系列用于数据统计的静态方法：
计数： count
平均值： averagingint、 averaginglong、 averagingdouble
最值： maxby、 minby
求和： summingint、 summinglong、 summingdouble
统计以上所有： summarizingint、 summarizinglong、 summarizingdouble
/** * 统计员工人数、平均工资、工资总额、最高工资 */private static void test01(){ //统计员工人数 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(求最高工资:+max); system.out.println(求工资之和:+sum); system.out.println(一次性统计所有信息:+collect);}
8、分组(partitioningby/groupingby)分区：将stream按条件分为两个 map，比如员工按薪资是否高于8000分为两部分。
分组：将集合分为多个map，比如员工按性别分组。有单级分组和多级分组。
将员工按薪资是否高于8000分为两部分；将员工按性别和地区分组
public class streamtest { public static void main(string[] args) { personlist.add(new person(zhangsan,25, 3000, male, tieling)); personlist.add(new person(lisi,27, 5000, male, tieling)); personlist.add(new person(wangwu,29, 7000, female, tieling)); personlist.add(new person(sunliu,26, 3000, female, dalian)); personlist.add(new person(yinqi,27, 5000, male, dalian)); personlist.add(new person(guba,21, 7000, female, dalian)); // 将员工按薪资是否高于8000分组 map part = personlist.stream().collect(collectors.partitioningby(x -> x.getsalary() > 8000)); // 将员工按性别分组 map group = personlist.stream().collect(collectors.groupingby(person::getsex)); // 将员工先按性别分组，再按地区分组 map 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); }}
9、连接joiningjoining可以将stream中的元素用特定的连接符（没有的话，则直接连接）连接成一个字符串。
10、排序sorted将员工按工资由高到低（工资一样则按年龄由大到小）排序
private static void test04(){ // 按工资升序排序（自然排序） 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);}
11、提取/组合流也可以进行合并、去重、限制、跳过等操作。
private static void test05(){ 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);}
12、读取文件的流操作
13、计算两个list中的差集//计算两个list中的差集list<string> reduce1 = alllist.stream().filter(item -> !wlist.contains(item)).collect(collectors.tolist());
推荐学习：《java视频教程》
以上就是java8中stream详细用法归纳的详细内容。