例：Composition对象的list集合
1、名字作为key，单位作为value，收集map集合，并且处理key冲突，key冲突的时候，用后面的值覆盖前面的值，不处理冲突会导致stream中断报错
List<Composition> compositionList = compositionRepository.findAll();
Map<String, String> compositionMaps = compositionList.stream().collect(Collectors.toMap(Composition::getCompositionName, Composition::getCompositionUnit, (oldValue, newValue) -> newValue));2、名字作为key，Composition实体作为value，收集map集合，并且处理key冲突，key冲突的时候，用后面的值覆盖前面的值，不处理冲突会导致stream中断报错
Map<String, Composition> collect = compositionList.stream().collect(Collectors.toMap(Composition::getCompositionName, Function.identity(), (oldValue, newValue) -> newValue));3、收集map中loss_rate_value键对应的Double值的List集合
并用stream流处理List<Double>，求出最小值
List<Map<String, Object>> resultList = jdbcTemplate.queryForList(String.valueOf(resSql));
List<Double> lossRateValueList = resultList.stream().map(objectMap -> Double.parseDouble(MapUtils.getString(objectMap, "loss_rate_value"))).collect(Collectors.toList());
OptionalDouble optionalDoubleMin = lossRateValueList.stream().mapToDouble(Double::doubleValue).min();
if (optionalDoubleMin.isPresent()) {
compositionStatisticsDto.setLossRateValueMin(BigDecimal.valueOf(optionalDoubleMin.getAsDouble()));
}- 筛选出卡路里小于400的菜肴
- 对筛选出的菜肴进行一个排序
- 获取排序后菜肴的名字
private List<String> afterJava8(List<Dish> dishList) {
return dishList.stream()
.filter(d -> d.getCalories() < 400) //筛选出卡路里小于400的菜肴
.sorted(comparing(Dish::getCalories)) //根据卡路里进行排序
.map(Dish::getName) //提取菜肴名称
.collect(Collectors.toList()); //转换为List
}对数据库查询到的菜肴根据菜肴种类进行分类，返回一个Map<Type, List<Dish>>的结果
private static Map<Type, List<Dish>> afterJdk8(List<Dish> dishList) {
return dishList.stream().collect(groupingBy(Dish::getType));
}filter筛选、distinct去除重复元素、limit返回指定流个数、skip跳过流中的元素
List<Integer> integerList = Arrays.asList(1, 1, 2, 3, 4, 5);
Stream<Integer> stream = integerList.stream().filter(i -> i > 3);
Stream<Integer> stream = integerList.stream().distinct();
Stream<Integer> stream = integerList.stream().limit(3);
Stream<Integer> stream = integerList.stream().skip(2);flatMap流转换
将一个流中的每个值都转换为另一个流，map(w -> w.split(" "))的返回值为Stream<String[]>，我们想获取Stream<String>，可以通过flatMap方法完成Stream<String[]> ->Stream<String>的转换
List<String> wordList = Arrays.asList("Hello", "World");
List<String> strList = wordList.stream()
.map(w -> w.split(" "))
.flatMap(Arrays::stream)
.distinct()
.collect(Collectors.toList());元素匹配
提供了三种匹配方式
1.allMatch匹配所有
2.anyMatch匹配其中一个
3.noneMatch全部不匹配
List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
if (integerList.stream().allMatch(i -> i > 3)) {
System.out.println("值都大于3");
}
if (integerList.stream().anyMatch(i -> i > 3)) {
System.out.println("存在大于3的值");
}
if (integerList.stream().noneMatch(i -> i > 3)) {
System.out.println("值都小于3");
}终端操作
统计流中元素个数
1.通过count
2.通过counting
List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
Long result = integerList.stream().count();
Long result = integerList.stream().collect(counting());查找
提供了两种查找方式
1.findFirst查找第一个，通过findFirst方法查找到第一个大于三的元素并打印
2.findAny随机查找一个，通过findAny方法查找到其中一个大于三的元素并打印，因为内部进行优化的原因，当找到第一个满足大于三的元素时就结束，该方法结果和findFirst方法结果一样。提供findAny方法是为了更好的利用并行流，findFirst方法在并行上限制更多
List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> result = integerList.stream().filter(i -> i > 3).findFirst();
Optional<Integer> result = integerList.stream().filter(i -> i > 3).findAny();reduce将流中的元素组合起来
reduce接受两个参数，一个初始值这里是0，一个BinaryOperator<T> accumulator
来将两个元素结合起来产生一个新值，另外reduce方法还有一个没有
初始化值的重载方法
int sum = integerList.stream().reduce(0, (a, b) -> (a + b));
int sum = integerList.stream().reduce(0, Integer::sum);获取流中最小最大值
通过min/max获取最小最大值
min获取流中最小值，max获取流中最大值，方法参数为Comparator<? super T> comparator
通过minBy/maxBy获取最小最大值
minBy获取流中最小值，maxBy获取流中最大值，方法参数为Comparator<? super T> comparator
通过reduce获取最小最大值
如果数据类型为double、long，则通过summingDouble、summingLong方法进行求和
在求和、求最大值、最小值的时候，对于相同操作有不同的方法可以选择执行。可以选择collect、reduce、min/max/sum方法，推荐使用min、max、sum方法。因为它最简洁易读，同时通过mapToInt将对象流转换为数值流，避免了装箱和拆箱操作
通过averagingInt求平均值
如果数据类型为double、long，则通过averagingDouble、averagingLong方法进行求平均
通过summarizingInt同时求总和、平均值、最大值、最小值
如果数据类型为double、long，则通过summarizingDouble、summarizingLong方法
Optional<Integer> min = menu.stream().map(Dish::getCalories).min(Integer::compareTo);
Optional<Integer> max = menu.stream().map(Dish::getCalories).max(Integer::compareTo);
OptionalInt min = menu.stream().mapToInt(Dish::getCalories).min();
OptionalInt max = menu.stream().mapToInt(Dish::getCalories).max();
Optional<Integer> min = menu.stream().map(Dish::getCalories).collect(minBy(Integer::compareTo));
Optional<Integer> max = menu.stream().map(Dish::getCalories).collect(maxBy(Integer::compareTo));
Optional<Integer> min = menu.stream().map(Dish::getCalories).reduce(Integer::min);
Optional<Integer> max = menu.stream().map(Dish::getCalories).reduce(Integer::max);
sum = menu.stream().collect(summingInt(Dish::getCalories));
sum = menu.stream().map(Dish::getCalories).reduce(0, Integer::sum);
int sum = menu.stream().mapToInt(Dish::getCalories).sum();
double average = menu.stream().collect(averagingInt(Dish::getCalories));
IntSummaryStatistics intSummaryStatistics = menu.stream().collect(summarizingInt(Dish::getCalories));
double average = intSummaryStatistics.getAverage(); //获取平均值
int min = intSummaryStatistics.getMin(); //获取最小值
int max = intSummaryStatistics.getMax(); //获取最大值
long sum = intSummaryStatistics.getSum(); //获取总和通过joining拼接流中的元素、通过groupingBy进行分组
在collect方法中传入groupingBy进行分组，其中groupingBy的方法参数为分类函数。还可以通过嵌套使用groupingBy进行多级分类
通过partitioningBy进行分区
分区是特殊的分组，它分类依据是true和false，所以返回的结果最多可以分为两组
Map<Boolean, List<Dish>> result = menu.stream().collect(partitioningBy(Dish :: isVegetarian));
Map<Boolean, List<Dish>> result = menu.stream().collect(groupingBy(Dish :: isVegetarian));
List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
Map<Boolean, List<Integer>> result = integerList.stream().collect(partitioningBy(i -> i < 3));
