From 835e7bf66d61ba33426ad32db48e014cd96353b9 Mon Sep 17 00:00:00 2001 From: huahua Date: Mon, 13 Feb 2023 21:09:53 +0800 Subject: [PATCH] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E9=92=88=E5=AF=B9=20bigDecim?= =?UTF-8?q?al=E7=B1=BB=E5=9E=8B=E7=9A=84avg=E6=96=B9=E6=B3=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../cn/hutool/core/stream/EasyStream.java | 35 ++++ .../cn/hutool/core/stream/EasyStreamTest.java | 161 +++++++++++------- 2 files changed, 135 insertions(+), 61 deletions(-) diff --git a/hutool-core/src/main/java/cn/hutool/core/stream/EasyStream.java b/hutool-core/src/main/java/cn/hutool/core/stream/EasyStream.java index b84fefc03..9001d19cf 100644 --- a/hutool-core/src/main/java/cn/hutool/core/stream/EasyStream.java +++ b/hutool-core/src/main/java/cn/hutool/core/stream/EasyStream.java @@ -1,13 +1,19 @@ package cn.hutool.core.stream; +import cn.hutool.core.collection.CollUtil; import cn.hutool.core.lang.Opt; +import cn.hutool.core.math.NumberUtil; import cn.hutool.core.util.ArrayUtil; import cn.hutool.core.util.ObjUtil; +import java.math.BigDecimal; +import java.math.RoundingMode; +import java.util.List; import java.util.Objects; import java.util.OptionalDouble; import java.util.Spliterator; import java.util.function.*; +import java.util.stream.Collectors; import java.util.stream.Stream; import java.util.stream.StreamSupport; @@ -299,6 +305,34 @@ public class EasyStream extends AbstractEnhancedWrappedStream mapper) { + return stream.map(mapper).reduce(BigDecimal.ZERO, BigDecimal::add); + } + + /** + * 计算bigDecimal平均值 + * @param mapper 映射 + * @param scale 精度 + * @param roundingMode 舍入模式 + * @return 如果元素的长度为0 那么会返回为空的opt + */ + public Opt avg(final Function mapper,int scale,RoundingMode roundingMode){ + //元素列表 + List bigDecimalList = stream.map(mapper).collect(Collectors.toList()); + if (CollUtil.isEmpty(bigDecimalList)){ + return Opt.ofNullable(null); + } + + return Opt.of(EasyStream.of(bigDecimalList).reduce(BigDecimal.ZERO, BigDecimal::add).divide(NumberUtil.toBigDecimal(bigDecimalList.size()),scale, roundingMode)); + } + + /** @@ -333,6 +367,7 @@ public class EasyStream extends AbstractEnhancedWrappedStream orders = Arrays.asList(1, 2, 3, 2); final List list = Arrays.asList("dromara", "guava", "sweet", "hutool"); final Map map = MapUtil.builder() - .put(1, "dromara") - .put(2, "hutool") - .put(3, "sweet") - .build(); + .put(1, "dromara") + .put(2, "hutool") + .put(3, "sweet") + .build(); final Map toZip = EasyStream.of(orders).toZip(list); Assert.assertEquals(map, toZip); @@ -122,15 +126,15 @@ public class EasyStreamTest { final List list = Arrays.asList(1, 2, 3); final Map> group = EasyStream.of(list).group(String::valueOf); Assert.assertEquals( - new HashMap>() { - private static final long serialVersionUID = 1L; + new HashMap>() { + private static final long serialVersionUID = 1L; - { - put("1", singletonList(1)); - put("2", singletonList(2)); - put("3", singletonList(3)); - } - }, group); + { + put("1", singletonList(1)); + put("2", singletonList(2)); + put("3", singletonList(3)); + } + }, group); } @Test @@ -140,7 +144,7 @@ public class EasyStreamTest { Assert.assertEquals(Arrays.asList("1.dromara", "2.hutool", "3.sweet"), mapIndex); // 并行流时正常 Assert.assertEquals(Arrays.asList("1.dromara", "2.hutool", "3.sweet"), - EasyStream.of("dromara", "hutool", "sweet").parallel().mapIdx((e, i) -> i + 1 + "." + e).toList()); + EasyStream.of("dromara", "hutool", "sweet").parallel().mapIdx((e, i) -> i + 1 + "." + e).toList()); } @Test @@ -181,7 +185,7 @@ public class EasyStreamTest { Assert.assertEquals(ListUtil.sort(collect2), ListUtil.sort(distinctBy2)); Assert.assertEquals( - 4, EasyStream.of(1, 2, 2, null, 3, null).parallel(true).distinct(t -> Objects.isNull(t) ? null : t.toString()).sequential().count() + 4, EasyStream.of(1, 2, 2, null, 3, null).parallel(true).distinct(t -> Objects.isNull(t) ? null : t.toString()).sequential().count() ); } @@ -217,28 +221,28 @@ public class EasyStreamTest { Assert.assertEquals(Arrays.asList("1.dromara", "2.hutool", "3.sweet"), mapIndex); // 并行流时正常 Assert.assertEquals(Arrays.asList("1.dromara", "2.hutool", "3.sweet"), - EasyStream.of("dromara", "hutool", "sweet").parallel() - .flatMapIdx((e, i) -> EasyStream.of(i + 1 + "." + e)).toList()); + EasyStream.of("dromara", "hutool", "sweet").parallel() + .flatMapIdx((e, i) -> EasyStream.of(i + 1 + "." + e)).toList()); } @Test public void testPeek() { EasyStream.of("one", "two", "three", "four") - .filter(e -> e.length() == 4) - .peek(e -> Assert.assertEquals("four", e)) - .map(String::toUpperCase) - .peek(e -> Assert.assertEquals("FOUR", e)) - .collect(Collectors.toList()); + .filter(e -> e.length() == 4) + .peek(e -> Assert.assertEquals("four", e)) + .map(String::toUpperCase) + .peek(e -> Assert.assertEquals("FOUR", e)) + .collect(Collectors.toList()); } @Test public void testPeekIdx() { EasyStream.of("one", "two", "three", "four") - .filter(e -> e.length() == 4) - .peekIdx((e, i) -> Assert.assertEquals("four:0", e + ":" + i)) - .map(String::toUpperCase) - .peekIdx((e, i) -> Assert.assertEquals("FOUR:0", e + ":" + i)) - .collect(Collectors.toList()); + .filter(e -> e.length() == 4) + .peekIdx((e, i) -> Assert.assertEquals("four:0", e + ":" + i)) + .map(String::toUpperCase) + .peekIdx((e, i) -> Assert.assertEquals("FOUR:0", e + ":" + i)) + .collect(Collectors.toList()); } @Test @@ -274,7 +278,7 @@ public class EasyStreamTest { Assert.assertEquals(Arrays.asList("dromara", "hutool"), filterIndex); // 并行流时正常 Assert.assertEquals(Arrays.asList("dromara", "hutool"), - EasyStream.of("dromara", "hutool", "sweet").parallel().filterIdx((e, i) -> i < 2).toList()); + EasyStream.of("dromara", "hutool", "sweet").parallel().filterIdx((e, i) -> i < 2).toList()); } @Test @@ -380,23 +384,23 @@ public class EasyStreamTest { final List list = EasyStream.iterate(1, i -> i <= 10, i -> i + 1).toList(); final List res1 = EasyStream.of(list) - // 舍弃 5 - .takeWhile(e -> e < 5) - // 过滤奇数 - .filter(e -> (e & 1) == 0) - // 反序 - .sorted(Comparator.reverseOrder()) - .map(String::valueOf) - .toList(); + // 舍弃 5 + .takeWhile(e -> e < 5) + // 过滤奇数 + .filter(e -> (e & 1) == 0) + // 反序 + .sorted(Comparator.reverseOrder()) + .map(String::valueOf) + .toList(); Assert.assertEquals(Arrays.asList("4", "2"), res1); final List res2 = EasyStream.iterate(1, i -> i + 1) - .parallel() - .takeWhile(e -> e < 5) - .map(String::valueOf) - .map(Integer::valueOf) - .sorted(Comparator.naturalOrder()) - .toList(); + .parallel() + .takeWhile(e -> e < 5) + .map(String::valueOf) + .map(Integer::valueOf) + .sorted(Comparator.naturalOrder()) + .toList(); Assert.assertEquals(Arrays.asList(1, 2, 3, 4), res2); } @@ -406,25 +410,25 @@ public class EasyStreamTest { final List list = EasyStream.iterate(1, i -> i <= 10, i -> i + 1).toList(); final List res1 = EasyStream.of(list) - // 舍弃 5之前的数字 - .dropWhile(e -> e < 5) - // 过滤偶数 - .filter(e -> (e & 1) == 1) - // 反序 - .sorted(Comparator.reverseOrder()) - .map(String::valueOf) - .toList(); + // 舍弃 5之前的数字 + .dropWhile(e -> e < 5) + // 过滤偶数 + .filter(e -> (e & 1) == 1) + // 反序 + .sorted(Comparator.reverseOrder()) + .map(String::valueOf) + .toList(); Assert.assertEquals(Arrays.asList("9", "7", "5"), res1); final List res2 = EasyStream.of(list) - .parallel() - .dropWhile(e -> e < 5) - // 过滤偶数 - .filter(e -> (e & 1) == 1) - .map(String::valueOf) - .map(Integer::valueOf) - .sorted(Comparator.naturalOrder()) - .toList(); + .parallel() + .dropWhile(e -> e < 5) + // 过滤偶数 + .filter(e -> (e & 1) == 1) + .map(String::valueOf) + .map(Integer::valueOf) + .sorted(Comparator.naturalOrder()) + .toList(); Assert.assertEquals(Arrays.asList(5, 7, 9), res2); } @@ -435,11 +439,46 @@ public class EasyStreamTest { @Test - public void testIntSum() { + public void testIntSumAndAvg() { int sum = EasyStream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).sum(Integer::intValue); - Assert.assertEquals(sum,55); - double doubleSum = EasyStream.of(1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.10).sum(Double::doubleValue); - Assert.assertEquals(doubleSum,59.6); + Assert.assertEquals(sum, 55); + + //测试为空 + List integerList = new ArrayList<>(); + int emptySum = EasyStream.of(integerList).sum(Integer::intValue); + Assert.assertEquals(emptySum, 0); } + @Test + public void testDoubleSumAndAvg() { + double doubleSum = EasyStream.of(1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.10).sum(Double::doubleValue); + Assert.assertEquals(doubleSum, 59.6,2); + + List doubleList = new ArrayList<>(); + double emptySum = EasyStream.of(doubleList).sum(Double::doubleValue); + Assert.assertEquals(emptySum, 0.0,2); + + } + + @Test + public void testLongSumAndAvg() { + long sum = EasyStream.of(1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L, 10L).sum(Long::longValue); + Assert.assertEquals(sum, 55); + + List longList = new ArrayList<>(); + double emptySum = EasyStream.of(longList).sum(Long::longValue); + Assert.assertEquals(emptySum, 0L); + + } + + @Test + public void testBigDecimalSumAndAvg() { + BigDecimal sum = EasyStream.of(NumberUtil.toBigDecimal(1.1), NumberUtil.toBigDecimal(2.2), NumberUtil.toBigDecimal(3.3), NumberUtil.toBigDecimal(4.4), NumberUtil.toBigDecimal(5.5), NumberUtil.toBigDecimal(6.6), NumberUtil.toBigDecimal(7.7), NumberUtil.toBigDecimal(8.8), NumberUtil.toBigDecimal(9.9), NumberUtil.toBigDecimal(10.10)).sum(Function.identity()); + Assert.assertEquals(sum, 59.6); + + List bigDecimalList = new ArrayList<>(); + BigDecimal emptySum = EasyStream.of(bigDecimalList).sum(Function.identity()); + Assert.assertEquals(emptySum, BigDecimal.ZERO); + + } }