中间操作
Stream 常用 API:
以下为测试用实体类,代码省略了 getter、settter 和构造方法
订单项
public class OrderItem {
private Long productId;// 商品ID
private String productName;// 商品名称
private Double productPrice;// 商品价格
private Integer productQuantity;// 商品数量
}
订单
public class Order {
private Long id;
private Long customerId;// 顾客ID
private String customerName;// 顾客姓名
private List orderItemList;// 订单商品明细
private Double totalPrice;// 总价格
private LocalDateTime placedAt;// 下单时间
}
消费者
public class Customer {
private Long id;
private String name;// 顾客姓名
}
filter
filter 操作用作过滤,类似于 SQL 中的 where 条件,接收一个 Predicate 谓词对象作为参数,返回过滤后的流
可以连续使用 filter 进行多层过滤
// 查找最近半年的金额大于40的订单
orders.stream()
.filter(Objects::nonNull) // 过滤null值
.filter(order -> order.getPlacedAt()
.isAfter(LocalDateTime.now().minusMonths(6))) // 最近半年的订单
.filter(order -> order.getTotalPrice() > 40) // 金额大于40的订单
.forEach(System.out::println);
map
map 操作用做转换,也叫投影,类似于 SQL 中的 select
// 计算所有订单商品数量
// 1. 通过两次遍历实现
LongAdder longAdder = new LongAdder();
orders.stream().forEach(order ->
order.getOrderItemList().forEach(orderItem -> longAdder.add(orderItem.getProductQuantity())));
System.out.println("longAdder = " + longAdder);
// 2. 使用两次 mapToLong 和 sum 方法实现
long sum = orders.stream().mapToLong(
order -> order.getOrderItemList().stream()
.mapToLong(OrderItem::getProductQuantity)
.sum()
).sum();
flatMap
flatMap 是扁平化操作,即先用 map 把每个元素替换为一个流,再展开这个流
// 统计所有订单的总价格
// 1. 直接展开订单商品进行价格统计
double sum1 = orders.stream()
.flatMap(order -> order.getOrderItemList().stream())
.mapToDouble(item -> item.getProductQuantity() * item.getProductPrice())
.sum();
// 2. 另一种方式 flatMapToDouble,即 flatMap + mapToDouble,返回 DoubleStream
double sum2 = orders.stream()
.flatMapToDouble(order ->
order.getOrderItemList()
.stream().mapToDouble(item ->
item.getProductQuantity() * item.getProductPrice())
)
.sum();
sorted
sorted 是排序操作,类似 SQL 中的 order by 子句,接收一个 Comparator 作为参数,可使用 Comparator.comparing 来由大到小排列,加上 reversed 表示倒叙
// 大于 50 的订单,按照订单价格倒序前 5
orders.stream()
.filter(order -> order.getTotalPrice() > 50)
.sorted(Comparator.comparing(Order::getTotalPrice).reversed())
.limit(5)
.forEach(System.out::println);
skip & limit
skip 用于跳过流中的项,limit 用于限制项的个数
// 按照下单时间排序,查询前 2 个订单的顾客姓名
orders.stream()
.sorted(Comparator.comparing(Order::getPlacedAt))
.map(order -> order.getCustomerName())
.limit(2)
.forEach(System.out::println);
// 按照下单时间排序,查询第 3 和第 4 个订单的顾客姓名
orders.stream()
.sorted(Comparator.comparing(Order::getPlacedAt))
.map(order -> order.getCustomerName())
.skip(2).limit(2)
.
【一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义】
浏览器打开:qq.cn.hn/FTf 免费领取
forEach(System.out::println);
distinct
distinct 操作的作用是去重,类似 SQL 中的 distinct
// 去重的下单用户
orders.stream()
.map(Order::getCustomerName)
.distinct()
.forEach(System.out::println);
// 所有购买过的商品
orders.stream()
.flatMap(order -> order.getOrderItemList().stream())
.map(OrderItem::getProductName)
.distinct()
.forEach(System.out::println);
终结操作
forEach
上文中已经多次使用,内部循环流中的所有元素,对每一个元素进行消费
forEachOrder 和 forEach 类似,但能保证消费顺序
count
返回流中项的个数
toArray
转换流为数组
anyMatch
短路操作,有一项匹配就返回 true
// 查询是否存在总价在 100 元以上的订单
boolean b = orders.stream()
.filter(order -> order.getTotalPrice() > 50)
.anyMatch(order -> order.getTotalPrice() > 100);
其他短路操作:
allMatch:全部匹配才返回 true
noneMatch:都不匹配才返回 true
findFirst:返回第一项的 Optional 包装
findAny:返回任意一项的 Optional 包装,串行流一般返回第一个
reduce
归纳,一边遍历,一边将处理结果保持起来,代入下一次循环
重载方法有三个,截图来自 IDEA 参数提示:
// 一个参数
// 求订单金额总价
Optional reduce = orders.stream()
.map(Order::getTotalPrice)
.reduce((p, n) -> {
return p + n;
});
// 两个参数
// 可指定一个初始值,初始值类型需要和 p、n 一致
Double reduce2 = orders.stream()
.map(Order::getTotalPrice)
.reduce(0.0, (p, n) -> {
return p + n;
});
三个参数的 reduce 方法:
可以接收一个目标结果类型的初始值,一个串行的处理函数,一个并行的合并函数
// 将所有订单的顾客名字进行拼接
// 第一个参数为目标结果类型,这里设置为空的 StringBuilder
// 第二个参数 BiFunction,参数为上一次的 StringBuilder 和流中的下一项,返回新的 StringBuilder
// 第三个参数 BinaryOperator,参数都是 StringBuilder,返回合并后的 StringBuilder
StringBuilder reduce = orders.stream()
.reduce(new StringBuilder(),
(sb, next) -> {
return sb.append(next.getCustomerName() + “,”);
},
(sb1, sb2) -> {
return sb1.append(sb2);
});
其他归纳方法:
max/min 求最大/最小值,接收一个比较器作为参数
对于 LongStream 等基础类型 Stream,则不需要传入比较器参数
collect
collect 是收集操作,对流进行终结操作,把流导出为我们需要的数据结构
collect 需要接收一个收集器 Collector 对象作为参数,JDK 内置的 Collector 的实现类 Collectors 包含了许多常用的导出方式
collect 常用 API:
导出流为集合:
- toList 和 toUnmodifiableList
// 转为 List(ArrayList)
orders.stream().collect(Collectors.toList());
// 转为不可修改的 List
orders.collect(Collectors.toUnmodifiableList());
- toSet 和 toUnmodifiableSet
// 转为 Set
orders.stream().collect(Collectors.toSet());
// 转为不可修改的 Set
orders.stream().collect(Collectors.toUnmodifiableSet());
- toCollection 指定集合类型,如 LinkedList
orders.stream().collect(Collectors.toCollection(LinkedList::new));
导出流为 Map:
- toMap,第三个参数可以指定键名重复时选择键值的规则
// 使用 toMap 获取订单 ID + 下单用户名的 Map
orders.stream()
.collect(Collectors.toMap(Order::getId, Order::getCustomerName))
.entrySet().forEach(System.out::println);
//使用 toMap 获取下单用户名 + 最近一次下单时间的 Map
orders.stream()
.collect(Collectors.toMap(Order::getCustomerName, Order::getPlacedAt,
(x, y) -> x.isAfter(y) ? x : y))
.entrySet().forEach(System.out::println);
-
toUnmodifiableMap:返回一个不可修改的 Map
-
toConcurrentMap:返回一个线程安全的 Map
分组导出:
在 toMap 中遇到重复的键名,通过指定一个处理函数来选择一个键值保留
大多数情况下,我们需要根据键名分组得到 Map,Collectors.groupingBy 是更好的选择
重载方法有三个,截图来自 IDEA 参数提示:
一个参数,等同于第二个参数为 Collectors.toList,即键值为 List 类型
// 按照下单用户名分组,键值是该顾客对应的订单 List
Map<String, List> collect = orders.stream()
.collect(Collectors.groupingBy(Order::getCustomerName));
两个参数,第二个参数用于指定键值类型
// 按照下单用户名分组,键值是该顾客对应的订单数量
Map<String, Long> collect = orders.stream()
.collect(Collectors.groupingBy(Order::getCustomerName,
Collectors.counting()));