32 加餐2:带你吃透课程中Java 8的那些重要知识点(二)
你好,我是朱晔。
上一讲的几个例子中,其实都涉及了Stream API的最基本使用方法。今天,我会与你详细介绍复杂、功能强大的Stream API。
Stream流式操作,用于对集合进行投影、转换、过滤、排序等,更进一步地,这些操作能链式串联在一起使用,类似于SQL语句,可以大大简化代码。可以说,Stream操作是Java 8中最重要的内容,也是这个课程大部分代码都会用到的操作。
我先说明下,有些案例可能不太好理解,建议你对着代码逐一到源码中查看Stream操作的方法定义,以及JDK中的代码注释。
Stream操作详解
为了方便你理解Stream的各种操作,以及后面的案例,我先把这节课涉及的Stream操作汇总到了一张图中。你可以先熟悉一下。
在接下来的讲述中,我会围绕订单场景,给出如何使用Stream的各种API完成订单的统计、搜索、查询等功能,和你一起学习Stream流式操作的各种方法。你可以结合代码中的注释理解案例,也可以自己运行源码观察输出。
我们先定义一个订单类、一个订单商品类和一个顾客类,用作后续Demo代码的数据结构:
//订单类
@Data
public class Order {
private Long id;
private Long customerId;//顾客ID
private String customerName;//顾客姓名
private List<OrderItem> orderItemList;//订单商品明细
private Double totalPrice;//总价格
private LocalDateTime placedAt;//下单时间
}
//订单商品类
@Data
@AllArgsConstructor
@NoArgsConstructor
public class OrderItem {
private Long productId;//商品ID
private String productName;//商品名称
private Double productPrice;//商品价格
private Integer productQuantity;//商品数量
}
//顾客类
@Data
@AllArgsConstructor
public class Customer {
private Long id;
private String name;//顾客姓名
}
在这里,我们有一个orders字段保存了一些模拟数据,类型是List。这里,我就不贴出生成模拟数据的代码了。这不会影响你理解后面的代码,你也可以自己下载源码阅读。
创建流
要使用流,就要先创建流。创建流一般有五种方式:
- 通过stream方法把List或数组转换为流;
- 通过Stream.of方法直接传入多个元素构成一个流;
- 通过Stream.iterate方法使用迭代的方式构造一个无限流,然后使用limit限制流元素个数;
- 通过Stream.generate方法从外部传入一个提供元素的Supplier来构造无限流,然后使用limit限制流元素个数;
- 通过IntStream或DoubleStream构造基本类型的流。
//通过stream方法把List或数组转换为流
@Test
public void stream()
{
Arrays.asList("a1", "a2", "a3").stream().forEach(System.out::println);
Arrays.stream(new int[]{1, 2, 3}).forEach(System.out::println);
}
//通过Stream.of方法直接传入多个元素构成一个流
@Test
public void of()
{
String[] arr = {"a", "b", "c"};
Stream.of(arr).forEach(System.out::println);
Stream.of("a", "b", "c").forEach(System.out::println);
Stream.of(1, 2, "a").map(item -> item.getClass().getName()).forEach(System.out::println);
}
//通过Stream.iterate方法使用迭代的方式构造一个无限流,然后使用limit限制流元素个数
@Test
public void iterate()
{
Stream.iterate(2, item -> item * 2).limit(10).forEach(System.out::println);
Stream.iterate(BigInteger.ZERO, n -> n.add(BigInteger.TEN)).limit(10).forEach(System.out::println);
}
//通过Stream.generate方法从外部传入一个提供元素的Supplier来构造无限流,然后使用limit限制流元素个数
@Test
public void generate()
{
Stream.generate(() -> "test").limit(3).forEach(System.out::println);
Stream.generate(Math::random).limit(10).forEach(System.out::println);
}
//通过IntStream或DoubleStream构造基本类型的流
@Test
public void primitive()
{
//演示IntStream和DoubleStream
IntStream.range(1, 3).forEach(System.out::println);
IntStream.range(0, 3).mapToObj(i -> "x").forEach(System.out::println);
IntStream.rangeClosed(1, 3).forEach(System.out::println);
DoubleStream.of(1.1, 2.2, 3.3).forEach(System.out::println);
//各种转换,后面注释代表了输出结果
System.out.println(IntStream.of(1, 2).toArray().getClass()); //class [I
System.out.println(Stream.of(1, 2).mapToInt(Integer::intValue).toArray().getClass()); //class [I
System.out.println(IntStream.of(1, 2).boxed().toArray().getClass()); //class [Ljava.lang.Object;
System.out.println(IntStream.of(1, 2).asDoubleStream().toArray().getClass()); //class [D
System.out.println(IntStream.of(1, 2).asLongStream().toArray().getClass()); //class [J
//注意基本类型流和装箱后的流的区别
Arrays.asList("a", "b", "c").stream() // Stream<String>
.mapToInt(String::length) // IntStream
.asLongStream() // LongStream
.mapToDouble(x -> x / 10.0) // DoubleStream
.boxed() // Stream<Double>
.mapToLong(x -> 1L) // LongStream
.mapToObj(x -> "") // Stream<String>
.collect(Collectors.toList());
}
filter
filter方法可以实现过滤操作,类似SQL中的where。我们可以使用一行代码,通过filter方法实现查询所有订单中最近半年金额大于40的订单,通过连续叠加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);
如果不使用Stream的话,必然需要一个中间集合来收集过滤后的结果,而且所有的过滤条件会堆积在一起,代码冗长且不易读。
map
map操作可以做转换(或者说投影),类似SQL中的select。为了对比,我用两种方式统计订单中所有商品的数量,前一种是通过两次遍历实现,后一种是通过两次mapToLong+sum方法实现:
//计算所有订单商品数量
//通过两次遍历实现
LongAdder longAdder = new LongAdder();
orders.stream().forEach(order ->
order.getOrderItemList().forEach(orderItem -> longAdder.add(orderItem.getProductQuantity())));
//使用两次mapToLong+sum方法实现
assertThat(longAdder.longValue(), is(orders.stream().mapToLong(order ->
order.getOrderItemList().stream()
.mapToLong(OrderItem::getProductQuantity).sum()).sum()));
显然,后一种方式无需中间变量longAdder,更直观。
这里再补充一下,使用for循环生成数据,是我们平时常用的操作,也是这个课程会大量用到的。现在,我们可以用一行代码使用IntStream配合mapToObj替代for循环来生成数据,比如生成10个Product元素构成List:
//把IntStream通过转换Stream<Project>
System.out.println(IntStream.rangeClosed(1,10)
.mapToObj(i->new Product((long)i, "product"+i, i*100.0))
.collect(toList()));
flatMap
接下来,我们看看flatMap展开或者叫扁平化操作,相当于map+flat,通过map把每一个元素替换为一个流,然后展开这个流。
比如,我们要统计所有订单的总价格,可以有两种方式:
- 直接通过原始商品列表的商品个数*商品单价统计的话,可以先把订单通过flatMap展开成商品清单,也就是把Order替换为Stream,然后对每一个OrderItem用mapToDouble转换获得商品总价,最后进行一次sum求和;
- 利用flatMapToDouble方法把列表中每一项展开替换为一个DoubleStream,也就是直接把每一个订单转换为每一个商品的总价,然后求和。
//直接展开订单商品进行价格统计
System.out.println(orders.stream()
.flatMap(order -> order.getOrderItemList().stream())
.mapToDouble(item -> item.getProductQuantity() * item.getProductPrice()).sum());
//另一种方式flatMap+mapToDouble=flatMapToDouble
System.out.println(orders.stream()
.flatMapToDouble(order ->
order.getOrderItemList()
.stream().mapToDouble(item -> item.getProductQuantity() * item.getProductPrice()))
.sum());
这两种方式可以得到相同的结果,并无本质区别。
sorted
sorted操作可以用于行内排序的场景,类似SQL中的order by。比如,要实现大于50元订单的按价格倒序取前5,可以通过Order::getTotalPrice方法引用直接指定需要排序的依据字段,通过reversed()实现倒序:
//大于50的订单,按照订单价格倒序前5
orders.stream().filter(order -> order.getTotalPrice() > 50)
.sorted(comparing(Order::getTotalPrice).reversed())
.limit(5)
.forEach(System.out::println);
distinct
distinct操作的作用是去重,类似SQL中的distinct。比如下面的代码实现:
- 查询去重后的下单用户。使用map从订单提取出购买用户,然后使用distinct去重。
- 查询购买过的商品名。使用flatMap+map提取出订单中所有的商品名,然后使用distinct去重。
//去重的下单用户
System.out.println(orders.stream().map(order -> order.getCustomerName()).distinct().collect(joining(",")));
//所有购买过的商品
System.out.println(orders.stream()
.flatMap(order -> order.getOrderItemList().stream())
.map(OrderItem::getProductName)
.distinct().collect(joining(",")));
skip & limit
skip和limit操作用于分页,类似MySQL中的limit。其中,skip实现跳过一定的项,limit用于限制项总数。比如下面的两段代码:
- 按照下单时间排序,查询前2个订单的顾客姓名和下单时间;
- 按照下单时间排序,查询第3和第4个订单的顾客姓名和下单时间。
//按照下单时间排序,查询前2个订单的顾客姓名和下单时间
orders.stream()
.sorted(comparing(Order::getPlacedAt))
.map(order -> order.getCustomerName() + "@" + order.getPlacedAt())
.limit(2).forEach(System.out::println);
//按照下单时间排序,查询第3和第4个订单的顾客姓名和下单时间
orders.stream()
.sorted(comparing(Order::getPlacedAt))
.map(order -> order.getCustomerName() + "@" + order.getPlacedAt())
.skip(2).limit(2).forEach(System.out::println);
collect
collect是收集操作,对流进行终结(终止)操作,把流导出为我们需要的数据结构。“终结”是指,导出后,无法再串联使用其他中间操作,比如filter、map、flatmap、sorted、distinct、limit、skip。
在Stream操作中,collect是最复杂的终结操作,比较简单的终结操作还有forEach、toArray、min、max、count、anyMatch等,我就不再展开了,你可以查询JDK文档,搜索terminal operation或intermediate operation。
接下来,我通过6个案例,来演示下几种比较常用的collect操作:
- 第一个案例,实现了字符串拼接操作,生成一定位数的随机字符串。
- 第二个案例,通过Collectors.toSet静态方法收集为Set去重,得到去重后的下单用户,再通过Collectors.joining静态方法实现字符串拼接。
- 第三个案例,通过Collectors.toCollection静态方法获得指定类型的集合,比如把List转换为LinkedList。
- 第四个案例,通过Collectors.toMap静态方法将对象快速转换为Map,Key是订单ID、Value是下单用户名。
- 第五个案例,通过Collectors.toMap静态方法将对象转换为Map。Key是下单用户名,Value是下单时间,一个用户可能多次下单,所以直接在这里进行了合并,只获取最近一次的下单时间。
- 第六个案例,使用Collectors.summingInt方法对商品数量求和,再使用Collectors.averagingInt方法对结果求平均值,以统计所有订单平均购买的商品数量。
//生成一定位数的随机字符串
System.out.println(random.ints(48, 122)
.filter(i -> (i < 57 || i > 65) && (i < 90 || i > 97))
.mapToObj(i -> (char) i)
.limit(20)
.collect(StringBuilder::new, StringBuilder::append, StringBuilder::append)
.toString());
//所有下单的用户,使用toSet去重后实现字符串拼接
System.out.println(orders.stream()
.map(order -> order.getCustomerName()).collect(toSet())
.stream().collect(joining(",", "[", "]")));
//用toCollection收集器指定集合类型
System.out.println(orders.stream().limit(2).collect(toCollection(LinkedList::new)).getClass());
//使用toMap获取订单ID+下单用户名的Map
orders.stream()
.collect(toMap(Order::getId, Order::getCustomerName))
.entrySet().forEach(System.out::println);
//使用toMap获取下单用户名+最近一次下单时间的Map
orders.stream()
.collect(toMap(Order::getCustomerName, Order::getPlacedAt, (x, y) -> x.isAfter(y) ? x : y))
.entrySet().forEach(System.out::println);
//订单平均购买的商品数量
System.out.println(orders.stream().collect(averagingInt(order ->
order.getOrderItemList().stream()
.collect(summingInt(OrderItem::getProductQuantity)))));
可以看到,这6个操作使用Stream方式一行代码就可以实现,但使用非Stream方式实现的话,都需要几行甚至十几行代码。
有关Collectors类的一些常用静态方法,我总结到了一张图中,你可以再整理一下思路:
其中,groupBy和partitionBy比较复杂,我和你举例介绍。
groupBy
groupBy是分组统计操作,类似SQL中的group by子句。它和后面介绍的partitioningBy都是特殊的收集器,同样也是终结操作。分组操作比较复杂,为帮你理解得更透彻,我准备了8个案例:
- 第一个案例,按照用户名分组,使用Collectors.counting方法统计每个人的下单数量,再按照下单数量倒序输出。
- 第二个案例,按照用户名分组,使用Collectors.summingDouble方法统计订单总金额,再按总金额倒序输出。
- 第三个案例,按照用户名分组,使用两次Collectors.summingInt方法统计商品采购数量,再按总数量倒序输出。
- 第四个案例,统计被采购最多的商品。先通过flatMap把订单转换为商品,然后把商品名作为Key、Collectors.summingInt作为Value分组统计采购数量,再按Value倒序获取第一个Entry,最后查询Key就得到了售出最多的商品。
- 第五个案例,同样统计采购最多的商品。相比第四个案例排序Map的方式,这次直接使用Collectors.maxBy收集器获得最大的Entry。
- 第六个案例,按照用户名分组,统计用户下的金额最高的订单。Key是用户名,Value是Order,直接通过Collectors.maxBy方法拿到金额最高的订单,然后通过collectingAndThen实现Optional.get的内容提取,最后遍历Key/Value即可。
- 第七个案例,根据下单年月分组统计订单ID列表。Key是格式化成年月后的下单时间,Value直接通过Collectors.mapping方法进行了转换,把订单列表转换为订单ID构成的List。
- 第八个案例,根据下单年月+用户名两次分组统计订单ID列表,相比上一个案例多了一次分组操作,第二次分组是按照用户名进行分组。
//按照用户名分组,统计下单数量
System.out.println(orders.stream().collect(groupingBy(Order::getCustomerName, counting()))
.entrySet().stream().sorted(Map.Entry.<String, Long>comparingByValue().reversed()).collect(toList()));
//按照用户名分组,统计订单总金额
System.out.println(orders.stream().collect(groupingBy(Order::getCustomerName, summingDouble(Order::getTotalPrice)))
.entrySet().stream().sorted(Map.Entry.<String, Double>comparingByValue().reversed()).collect(toList()));
//按照用户名分组,统计商品采购数量
System.out.println(orders.stream().collect(groupingBy(Order::getCustomerName,
summingInt(order -> order.getOrderItemList().stream()
.collect(summingInt(OrderItem::getProductQuantity)))))
.entrySet().stream().sorted(Map.Entry.<String, Integer>comparingByValue().reversed()).collect(toList()));
//统计最受欢迎的商品,倒序后取第一个
orders.stream()
.flatMap(order -> order.getOrderItemList().stream())
.collect(groupingBy(OrderItem::getProductName, summingInt(OrderItem::getProductQuantity)))
.entrySet().stream()
.sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
.map(Map.Entry::getKey)
.findFirst()
.ifPresent(System.out::println);
//统计最受欢迎的商品的另一种方式,直接利用maxBy
orders.stream()
.flatMap(order -> order.getOrderItemList().stream())
.collect(groupingBy(OrderItem::getProductName, summingInt(OrderItem::getProductQuantity)))
.entrySet().stream()
.collect(maxBy(Map.Entry.comparingByValue()))
.map(Map.Entry::getKey)
.ifPresent(System.out::println);
//按照用户名分组,选用户下的总金额最大的订单
orders.stream().collect(groupingBy(Order::getCustomerName, collectingAndThen(maxBy(comparingDouble(Order::getTotalPrice)), Optional::get)))
.forEach((k, v) -> System.out.println(k + "#" + v.getTotalPrice() + "@" + v.getPlacedAt()));
//根据下单年月分组,统计订单ID列表
System.out.println(orders.stream().collect
(groupingBy(order -> order.getPlacedAt().format(DateTimeFormatter.ofPattern("yyyyMM")),
mapping(order -> order.getId(), toList()))));
//根据下单年月+用户名两次分组,统计订单ID列表
System.out.println(orders.stream().collect
(groupingBy(order -> order.getPlacedAt().format(DateTimeFormatter.ofPattern("yyyyMM")),
groupingBy(order -> order.getCustomerName(),
mapping(order -> order.getId(), toList())))));
如果不借助Stream转换为普通的Java代码,实现这些复杂的操作可能需要几十行代码。
partitionBy
partitioningBy用于分区,分区是特殊的分组,只有true和false两组。比如,我们把用户按照是否下单进行分区,给partitioningBy方法传入一个Predicate作为数据分区的区分,输出是Map<Boolean, List<T>>:
public static <T>
Collector<T, ?, Map<Boolean, List<T>>> partitioningBy(Predicate<? super T> predicate) {
return partitioningBy(predicate, toList());
}
测试一下,partitioningBy配合anyMatch,可以把用户分为下过订单和没下过订单两组:
//根据是否有下单记录进行分区
System.out.println(Customer.getData().stream().collect(
partitioningBy(customer -> orders.stream().mapToLong(Order::getCustomerId)
.anyMatch(id -> id == customer.getId()))));
重点回顾
今天,我用了大量的篇幅和案例,和你展开介绍了Stream中很多具体的流式操作方法。有些案例可能不太好理解,我建议你对着代码逐一到源码中查看这些操作的方法定义,以及JDK中的代码注释。
最后,我建议你思考下,在日常工作中还会使用SQL统计哪些信息,这些SQL是否也可以用Stream来改写呢?Stream的API博大精深,但其中又有规律可循。这其中的规律主要就是,理清楚这些API传参的函数式接口定义,就能搞明白到底是需要我们提供数据、消费数据、还是转换数据等。那,掌握Stream的方法便是,多测试多练习,以强化记忆、加深理解。
今天用到的代码,我都放在了GitHub上,你可以点击这个链接查看。
思考与讨论
- 使用Stream可以非常方便地对List做各种操作,那有没有什么办法可以实现在整个过程中观察数据变化呢?比如,我们进行filter+map操作,如何观察filter后map的原始数据呢?
- Collectors类提供了很多现成的收集器,那我们有没有办法实现自定义的收集器呢?比如,实现一个MostPopularCollector,来得到List中出现次数最多的元素,满足下面两个测试用例:
assertThat(Stream.of(1, 1, 2, 2, 2, 3, 4, 5, 5).collect(new MostPopularCollector<>()).get(), is(2));
assertThat(Stream.of('a', 'b', 'c', 'c', 'c', 'd').collect(new MostPopularCollector<>()).get(), is('c'));
关于Java 8,你还有什么使用心得吗?我是朱晔,欢迎在评论区与我留言分享你的想法,也欢迎你把这篇文章分享给你的朋友或同事,一起交流。
- 汝林外史 👍(4) 💬(1)
private List<Map> getNoRoomList(List<Map> inspectRooms, List<Map> items) { boolean flag = false; List<Map> noInspectRoom = new ArrayList<>(); for (Map item: items) { for (Map inspectRoom: inspectRooms) { if (inspectRoom.get("project").equals(item.get("checkItem"))) { flag = true; break; } } if (!flag) { noInspectRoom.add(item); }else { flag = false; } } return noInspectRoom; } 我直接贴我写的处理代码吧,应该可以理解我的想法,这测试用例还真不好写。
2020-03-20 - 海拉鲁 👍(12) 💬(2)
为了写作业又去翻了《Java 8 实战》,测试终于通过了 public class MostPopularCollector implements Collector<Object, // 收集String流 Map<Object, Integer>, // 累加器是一个Map,key为字符,value为出现的次数 Optional> // 返回的是出现次数最多的字符 { /** * 返回一个在调用时创建的累加器 * @return */ public Supplier<Map<Object, Integer>> supplier() { return () -> new HashMap<>(); } /** * 定义收集流中数据逻辑 * @return */ public BiConsumer<Map<Object, Integer>, Object> accumulator() { return (Map<Object, Integer> acc, Object chart) -> acc.compute(chart, (key, val) -> val == null ? 1 : val + 1); // 如果当前字符未统计则统计为1,否则+1 } /** * 处理并行操作,其实就是将两个map合成一个,把value加起来 * @return */ public BinaryOperator<Map<Object, Integer>> combiner() { return (Map<Object, Integer> m1, Map<Object, Integer> m2) -> { Map<Object, Integer> all = new HashMap<>(m1); m2.forEach((chart, count) -> all.merge(chart, count, Integer::sum)); return all; }; } public Function<Map<Object, Integer>, Optional> finisher() { return (Map<Object, Integer> acc) -> Optional.ofNullable(acc.entrySet() .stream() .max(Map.Entry.comparingByValue()) .get().getKey()); } public Set<Characteristics> characteristics() { return Collections.unmodifiableSet(EnumSet.of(Characteristics.CONCURRENT)); } }
2020-03-17 - Wiggle Wiggle 👍(8) 💬(1)
Stream API 有个 peek 方法可以接收一个 consumer 来打印数据,可以接在任意 transformation 操作后面查看数据
2020-03-17 - Darren 👍(8) 💬(1)
以前真没有特意去关注收集器,看了做了,参考了2片文章: https://www.cnblogs.com/yw0219/p/9589124.html https://my.oschina.net/piorcn/blog/424375 最终搞定,请老师指点 https://github.com/y645194203/geektime-java-100/blob/master/MostPopularCollector.java
2020-03-17 - pedro 👍(6) 💬(1)
我目前想到的数据观察的方式比较原始,一种是通过log打印,一种是debug。但我肯定这都不是啥好办法,希望老师告知解放生产力的方法。
2020-03-17 - Demon.Lee 👍(4) 💬(2)
每天晚上回去敲一点,花了好几个晚上,终于把这两节中的所有代码运行了一遍,只不过似懂非懂,还要继续练习。已经开始在工作中运用一些简单的了,读完这篇文章可能只需要20分钟,但把所有代码都练习一遍,就不是20分钟的事了,要持续学习才行。💪🏽
2020-04-24 - 汝林外史 👍(2) 💬(1)
List<Map> l1,List<Map> l2,两个list,l1中有四个map,其中有key分别为1、2、3、4的四个字段,l2有两个map,其中有key分别为1,2的l1中一样的字段,怎么筛选最终得到一个list,只有key为3、4对应的两个map?写的比较乱,还请老师见谅,我想了下没想出来,最后for循环做的。
2020-03-19 - insight 👍(2) 💬(1)
//各种转换,后面注释代表了输出结果 System.out.println(IntStream.of(1, 2).toArray().getClass()); //class [I System.out.println(Stream.of(1, 2).mapToInt(Integer::intValue).toArray().getClass()); //class [I System.out.println(IntStream.of(1, 2).boxed().toArray().getClass()); //class [Ljava.lang.Object; System.out.println(IntStream.of(1, 2).asDoubleStream().toArray().getClass()); //class [D System.out.println(IntStream.of(1, 2).asLongStream().toArray().getClass()); //class [J 老师,这一段代码的输出结果为什么是这样的呀?没看懂,求指教!
2020-03-18 - 鲁鸣 👍(1) 💬(1)
在实际中,发现distinct需要根据元素类型的属性进行判断,这个时候就需要用别的方式了
2020-09-27 - 大胖子呀、 👍(1) 💬(3)
工作中遇到一个需求,计算运费:先从运费集合中找出同一个客户的数据,然后类似于累加数量(还有很多其他的逻辑)计算出运费(因为相同的客户数量超过一定数值会有优惠)。最后把计算出来的运费数据插入到数据库里。 我的做法是:以第一条数据的客户为基准,循环找出相同客户的数据,保存到一个新的集合中,同时从原数据集合里移除这条数据,最后计算出新集合里的运费就可以了。 感觉这种需求的话,好像就没办法用老师介绍的流方法来遍历计算了,因为不能删除数据,不知道我认为的是不是对的。 另外就我的实现来说,会不会出现问题?有没有更好的解决方案?
2020-05-20 - 203。 👍(1) 💬(1)
老师 我这里有个问题 关于Stream的,业务需求里需要按某几个字段去重(acctId,billingCycleId,prodInstId,offerId) 我这里想到了遍历集合areaDatas 后用contains方法判断 重写AcctItemYzfBean实体类的equals方法实现, 请问有没有更好的方法? 代码如下 List<AcctItemYzfBean> newList = new CopyOnWriteArrayList<>(); //循环过滤、增强翼支付数据 Optional.ofNullable(areaDatas)//集合判空 .orElse(new ArrayList<>()) .stream()//转化为流 便于下面过滤和增强数据 .filter(Objects::nonNull)//元素判空 .filter(yzfBean -> this.judgeIfOfferId(yzfBean))//判断销售品ID是否相同 .filter(yzfBean -> this.enhanceYzfBean(yzfBean))//增强过滤accNbr和acctId .filter(yzfBean -> this.judgeIfArrears(yzfBean))//判断是否不欠费 .filter(yzfBean -> this.judgeIfCancel(yzfBean))//判断是否销账金额大于0 .filter(yzfBean -> this.judgeIfReturn(yzfBean))//判断是否上月未返还 .forEach(yzfBean -> { //去重 重写AcctItemYzfBean.equals方法 if(!newList.contains(yzfBean)) { //增强latnName yzfBean.setLatnName(commonRegionMap.get(yzfBean.getRegionId())); //增强areaCode yzfBean.setAreaCode(areaCode); //数据封装 newList.add(yzfBean); } }); 重写的equals方法 @Override public boolean equals(Object yzfBeanObj) { if(yzfBeanObj instanceof AcctItemYzfBean) { AcctItemYzfBean yzfBean = (AcctItemYzfBean) yzfBeanObj; if(Tools.isEmpty(yzfBean.getAcctId(), yzfBean.getBillingCycleId(), yzfBean.getProdInstId(), yzfBean.getOfferId())) { return false; } if(yzfBean.getAcctId().equals(this.acctId) && yzfBean.getBillingCycleId().equals(this.billingCycleId) && yzfBean.getProdInstId().equals(this.prodInstId) && yzfBean.getOfferId().equals(this.offerId)) { return true; } } return super.equals(yzfBeanObj); }
2020-05-12 - 阿怪 👍(1) 💬(1)
每天上下班阅读,收获满满
2020-03-25 - 陈天柱 👍(9) 💬(0)
老师把stream的常用api与sql操作联系起来,简直是太“亲民”了!
2020-03-20 - QQ怪 👍(8) 💬(0)
Idea 在debug模式有个Trace Current Stream Chain功能,可以很好的查看数据变化
2020-04-12 - 👽 👍(2) 💬(0)
个人认为,客户端不安全的主要原因是,计算机网络协议。 网络环境中一切都是不可预知,切不安全的。 无法保证你发出去的数据,就是服务器要的数据;也无法保证你发的数据顺序是1,2,3服务器收到的就是1,2,3.有可能服务器收到的是【3,2,1】 【 2,1,3】 【 3,1,2】,甚至有可能【111】或者压根收不到。 在网络中,传输数据的方式,方式是广播,无条件转发,就是任何人都有可能收到,所以必要的就是加密。防止对方知道。 任何人都能收到,任何人也都有权力继续转发,谁都不敢保证,转发的时候会不会给你增加些不安全的信息。这也就是服务端需要校验。
2020-05-20