Stream Api常用的案例汇总
简介
什么是 Stream？ Stream（流）是一个来自数据源的元素队列并支持聚合操作
元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。 数据源 流的来源。 可以是集合，数组，I/O
channel， 产生器generator 等。 聚合操作 类似SQL语句一样的操作， 比如filter, map, reduce,
find, match, sorted等。 和以前的Collection操作不同， Stream操作还有两个基础的特征：Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道， 如同流式风格（fluent style）。
这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting)。 内部迭代：
以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代， 这叫做外部迭代。
Stream提供了内部迭代的方式， 通过访问者模式(Visitor)实现。
生成流
在 Java 8 中, 集合接口有两个方法来生成流： stream() − 为集合创建串行流。 parallelStream() −
为集合创建并行流。
Stream的操作符大体上分为两种：中间操作符和终止操作符
中间操作符
对于数据流来说，中间操作符在执行制定处理程序后，数据流依然可以传递给下一级的操作符。
中间操作符包含8种(排除了parallel,sequential,这两个操作并不涉及到对数据流的加工操作)：
map(mapToInt,mapToLong,mapToDouble)
转换操作符，把比如A->B，这里默认提供了转int，long，double的操作符。flatmap(flatmapToInt,flatmapToLong,flatmapToDouble) 拍平操作比如把
int[]{2,3,4} 拍平 变成 2，3，4
也就是从原来的一个数据变成了3个数据，这里默认提供了拍平成int,long,double的操作符。limit 限流操作，比如数据流中有10个 我只要出前3个就可以使用。
distint 去重操作，对重复元素去重，底层使用了equals方法。
filter 过滤操作，把不想要的数据过滤。
peek 挑出操作，如果想对数据进行某些操作，如：读取、编辑修改等。
skip 跳过操作，跳过某些元素。
sorted(unordered) 排序操作，对元素排序，前提是实现Comparable接口，当然也可以自定义比较器。
/**
* skip limit 截断操作 从索引 值为 2开始 查询4个
*/
List<Integer> asList = Arrays.asList(1, 3, 5, 7, 9);
List<Integer> collect2 = asList.stream().skip(2).limit(4).collect(toList());
终止操作符
数据经过中间加工操作，就轮到终止操作符上场了；终止操作符就是用来对数据进行收集或者消费的，数据到了终止操作这里就不会向下流动了，终止操作符只能使用一次。
collect 收集操作，将所有数据收集起来，这个操作非常重要，官方的提供的Collectors 提供了非常多收集器，可以说Stream
的核心在于Collectors。count 统计操作，统计最终的数据个数。
findFirst、findAny 查找操作，查找第一个、查找任何一个 返回的类型为Optional。
noneMatch、allMatch、anyMatch 匹配操作，数据流中是否存在符合条件的元素 返回值为bool 值。
min、max 最值操作，需要自定义比较器，返回数据流中最大最小的值。
reduce 规约操作，将整个数据流的值规约为一个值，count、min、max底层就是使用reduce。
forEach、forEachOrdered 遍历操作，这里就是对最终的数据进行消费了。
toArray 数组操作，将数据流的元素转换成数组。
实例
/**
* 学生分数实体
*/
public class StuScore {
public Integer id;//学生id
private String name;//姓名
public Integer classId;//班级id
public String className;//班级名称
public BigDecimal score1;//分数1 BigDecimal类型
public Double score2; //分数2 Double类型
}
//学生分数列表
private static List<StuScore>list=new ArrayList<>();
static {
StuScore c = null;
for (int i = 10; i < 20; i++) {
c = new StuScore();
c.setId(i);
c.setName(i + "name");
c.setScore1(new BigDecimal(45 + i * 6));
c.setScore2((double) (45 + i * 6));
c.setClassId(2);
c.setClassName("二班");
list.add(c);
}
for (int i = 0; i < 10; i++) {
c = new StuScore();
c.setId(i);
c.setName(i + "name");
c.setScore1(new BigDecimal(40 + i * 5));
c.setScore2((double) (40 + i * 5));
c.setClassId(1);
c.setClassName("一班");
list.add(c);
}
Collections.sort(list, Comparator.comparing(StuScore::getId));//按照id升序
Collections.reverse(list);//反转倒序
Collections.reverse(list);//反转倒序
System.out.println("============集合init数据==================");
list.stream().forEach(t -> {
System.out.println(t);
});
System.out.println("============集合init数据==================");
}
初始化数据
==============================
==============================
StuScore{id=0, name=‘0name’, classId=1, className=‘一班’, score1=40, score2=40.0}
StuScore{id=1, name=‘1name’, classId=1, className=‘一班’, score1=45, score2=45.0}
StuScore{id=2, name=‘2name’, classId=1, className=‘一班’, score1=50, score2=50.0}
StuScore{id=3, name=‘3name’, classId=1, className=‘一班’, score1=55, score2=55.0}
StuScore{id=4, name=‘4name’, classId=1, className=‘一班’, score1=60, score2=60.0}
StuScore{id=5, name=‘5name’, classId=1, className=‘一班’, score1=65, score2=65.0}
StuScore{id=6, name=‘6name’, classId=1, className=‘一班’, score1=70, score2=70.0}
StuScore{id=7, name=‘7name’, classId=1, className=‘一班’, score1=75, score2=75.0}
StuScore{id=8, name=‘8name’, classId=1, className=‘一班’, score1=80, score2=80.0}
StuScore{id=9, name=‘9name’, classId=1, className=‘一班’, score1=85, score2=85.0}
StuScore{id=10, name=‘10name’, classId=2, className=‘二班’, score1=105, score2=105.0}
StuScore{id=11, name=‘11name’, classId=2, className=‘二班’, score1=111, score2=111.0}
StuScore{id=12, name=‘12name’, classId=2, className=‘二班’, score1=117, score2=117.0}
StuScore{id=13, name=‘13name’, classId=2, className=‘二班’, score1=123, score2=123.0}
StuScore{id=14, name=‘14name’, classId=2, className=‘二班’, score1=129, score2=129.0}
StuScore{id=15, name=‘15name’, classId=2, className=‘二班’, score1=135, score2=135.0}
StuScore{id=16, name=‘16name’, classId=2, className=‘二班’, score1=141, score2=141.0}
StuScore{id=17, name=‘17name’, classId=2, className=‘二班’, score1=147, score2=147.0}
StuScore{id=18, name=‘18name’, classId=2, className=‘二班’, score1=153, score2=153.0}
StuScore{id=19, name=‘19name’, classId=2, className=‘二班’, score1=159, score2=159.0}
==============================
==============================
分组
Map> map1 = list.stream().collect(Collectors.groupingBy(Student::getSchoolId));
Map> map2 = list.stream().collect(Collectors.groupingBy(Student::getSchoolId, Collectors.mapping(Student::getName, Collectors.toList())));
按照班级统计最大值，最小值，数量，总分，平均分
/**
* 如果实体分数是Double类型
*/
Map<Integer, Map<String, Object>> map1 = list.stream().collect(groupingBy(StuScore::getClassId, collectingAndThen(toList(), m -> {
Map<String, Object> map = new LinkedHashMap<>();
StuScore stuScore = m.stream().findAny().get();
map.put("classId", stuScore.getClassId());
map.put("className", stuScore.getClassName());
map.put("min", m.stream().mapToDouble(StuScore::getScore2).min().getAsDouble());
map.put("max", m.stream().mapToDouble(StuScore::getScore2).max().getAsDouble());
map.put("count", m.stream().mapToDouble(StuScore::getScore2).count());
map.put("sum", m.stream().mapToDouble(StuScore::getScore2).sum());
map.put("average", m.stream().mapToDouble(StuScore::getScore2).average().getAsDouble());
//上面单独求总数，数量以及平均数、下面直接统计上述所有
map.put("statistics", m.stream().mapToDouble(StuScore::getScore2).summaryStatistics());
return map;
})));
System.out.println("=========统计方法一============");
map1.values().stream().forEach(t -> {
System.out.println(t);
});
=统计方法一====
{classId=1, className=一班, min=40.0, max=85.0, count=10, sum=625.0, average=62.5, statistics=DoubleSummaryStatistics{count=10, sum=625.000000, min=40.000000, average=62.500000, max=85.000000}}
{classId=2, className=二班, min=105.0, max=159.0, count=10, sum=1320.0, average=132.0, statistics=DoubleSummaryStatistics{count=10, sum=1320.000000, min=105.000000, average=132.000000, max=159.000000}}
按照班级统计最大值，最小值，数量，总分，平均分
/**
* 如果实体分数是BigDecimal类型
*/
Map<Integer, Map<String, Object>> map2 = list.stream().collect(groupingBy(StuScore::getClassId, collectingAndThen(toList(), ms -> {
Map<String, Object> map = new LinkedHashMap<>();
StuScore stuScore = ms.stream().findAny().get();//取该流中的某个值
map.put("classId", stuScore.getClassId());
map.put("className", stuScore.getClassName());
/**
* reduce 循环计算
*/
BigDecimal sums = ms.stream()
.map(StuScore::getScore1)
.reduce((x, y) -> x.add(y)).get();//总数
long count = ms.stream().count();
BigDecimal average = sums.divide(new BigDecimal(count));
//正序排序；如果倒序排的话倒置；Comparator.comparing(StuScore::getScore1).reversed()
List<StuScore> collect = ms.stream().sorted(Comparator.comparing(StuScore::getScore1)).collect(toList());
BigDecimal min2 = ms.stream().map(StuScore::getScore1).min(BigDecimal::compareTo).get();
BigDecimal max2 = ms.stream().map(StuScore::getScore1).max((o1, o2) -> o1.compareTo(o2)).get();
map.put("min", collect.get(0).getScore1());
map.put("max", collect.get(collect.size() - 1).getScore1());
map.put("count", count);
map.put("sum", sums);
map.put("average", average);
map.put("min2", min2);
map.put("max2", max2);
return map;
})));
System.out.println("==========统计方法二===========");
map2.values().stream().forEach(t -> {
System.out.println(t);
});
统计方法二=
{classId=1, className=一班, min=40, max=85, count=10, sum=625, average=62.5, min2=40, max2=85}
{classId=2, className=二班, min=105, max=159, count=10, sum=1320, average=132, min2=105, max2=159}
实体去重
如果是包装类的集合可直接distinct()方法去重
/**
* 按照实体的某一个字段去重；也可以通过map 具体字段形成新的集合直接distinct()
*/
ArrayList<StuScore> collect1 = list.stream().collect(
collectingAndThen(
toCollection(() -> new TreeSet<>(Comparator.comparing(StuScore::getClassId))), ArrayList::new)
);
System.out.println("去重后的集合长度" + collect1.size());
去重后的集合长度2
聚合转换map,过滤filter
/**
* 聚合实体某一个字段形成新的集合
*/
List<Double> collect = list.stream().map(StuScore::getScore2).collect(toList());
/**filter 给定的条件进行过滤
* 分数大于60分的学生集合
*/
List<StuScore> collect4 = list.stream().filter(t -> t.getScore2() > 60).collect(toList());
List<StuScore> collect5 = list.stream().filter(t -> t.getScore1().compareTo(new BigDecimal(60)) > -1).collect(toList());
Collections排序sort
Collections.sort(list, Comparator.comparing(StuScore::getId));//按照id升序
Collections.reverse(list);//反转倒序
stream 排序sorted
/**
* 正序排序；如果倒序排的话倒置；Comparator.comparing(StuScore::getScore1).reversed()
*/
List<StuScore> collect = ms.stream().sorted(Comparator.comparing(StuScore::getScore1)).collect(toList());
其他操作
/** * 1.peek方法是消费型接口。 用于DEBUG * 调用peek方法后， 流还在。用于debug调试,不产生新的流，里面的方法没有执行 * 可以进行流操作的时候，返回新的流 * * foreach 直接消费掉，不返回新的流 * peek为中间操作，foreach为终端操作。 * peek执行体必须有终端语句才会被执行。 * * * 2.map方法是函数型接口。 * 调用map方法后，流已经被消费。 */ /** skip 跳过操作，跳过某些元素。 * skip limit 截断操作 从索引 值为 2开始 查询4个 */
System.out.println("============peek和foreach的操作============");
asList.stream().peek(t -> {
System.out.print(t);
}).collect(Collectors.toList());
System.out.println("\n==========================");
asList.stream().forEach(t -> {
System.out.print(t);
});
peek和foreach的操作 13579
========================== 13579
System.out.println("\n============map和flatMap===扁平化处理，处理字符串=============");
/**
* map对一位数组操作
* flatMap 对二维数组操作 将二维数组数据聚合到一位数组进行操作
*/
List<List<Integer>> lists = new ArrayList<>();
List<Integer> list22 = new ArrayList<>();
list22.add(2);
list22.add(22);
list22.add(222);
lists.add(list22);
List<Integer> list33 = new ArrayList<>();
list33.add(33);
lists.add(list33);
System.out.println("===========flatMap扁平化处理======================");
System.out.println(lists);
List<Integer> collect3 = lists.stream().flatMap(Collection::stream).collect(toList());
System.out.println(collect3);
map和flatMap=扁平化处理，处理字符串===
=flatMap扁平化处理============
[[2, 22, 222], [33]]
[2, 22, 222, 33]