zhouxy108/hutool
1
0
Fork 0
mirror of https://gitee.com/chinabugotech/hutool.git synced 2025-07-21 15:09:48 +08:00
Code Issues Packages Projects Releases Wiki Activity

!742 优化FastStream, 新增takeWhile、dropWhile方法

Browse Source 
Merge pull request !742 from emptypoint/FastStream-2
This commit is contained in:
Looly
2022-08-09 13:53:07 +00:00
committed by Gitee
parent db6e806f9e d2df665eaa
commit 04542f9a16
11 changed files with 736 additions and 184 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
hutool-core/src/test/java/cn/hutool/core/lang/OptTest.java
View File

@@ -8,13 +8,7 @@ import lombok.NoArgsConstructor;
import org.junit.Assert;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.*;
import java.util.stream.Stream;
/**
@@ -24,6 +18,12 @@ import java.util.stream.Stream;
*/
public class OptTest {
@Test
public void ofTest() {
Assert.assertTrue(Opt.of(Optional.empty()).isEmpty());
Assert.assertTrue(Opt.of(Optional.of(1)).isPresent());
}
@Test
public void ofBlankAbleTest() {
// ofBlankAble相对于ofNullable考虑了字符串为空串的情况

144
hutool-core/src/test/java/cn/hutool/core/stream/FastStreamTest.java
View File

@@ -23,6 +23,12 @@ public class FastStreamTest {
Assert.assertEquals(Arrays.asList(1, 2, 3), list);
}
@Test
public void testGenerate() {
List<Integer> list = FastStream.generate(() -> 0).limit(3).toList();
Assert.assertEquals(Arrays.asList(0, 0, 0), list);
}
@Test
public void testOf() {
Assert.assertEquals(3, FastStream.of(Arrays.asList(1, 2, 3), true).count());
@@ -76,7 +82,7 @@ public class FastStreamTest {
Map<Integer, String> toZip = FastStream.of(orders).toZip(list);
Assert.assertEquals(map, toZip);
Map<Integer, String> toZipParallel = FastStream.of(orders).parallel().toZip(list);
Map<Integer, String> toZipParallel = FastStream.of(orders).parallel().nonNull().toZip(list);
Assert.assertEquals(map, toZipParallel);
}
@@ -140,6 +146,13 @@ public class FastStreamTest {
Assert.assertEquals(Arrays.asList(1, 2, 2, 3, 3, 3), mapMulti);
}
@Test
public void testMapNonNull() {
List<Integer> list = Arrays.asList(1, 2, 3, null);
List<String> mapNonNull = FastStream.of(list).mapNonNull(String::valueOf).toList();
Assert.assertEquals(Arrays.asList("1", "2", "3"), mapNonNull);
}
@Test
public void testDistinct() {
List<Integer> list = ListUtil.of(3, 2, 2, 1, null, null);
@@ -174,6 +187,11 @@ public class FastStreamTest {
FastStream.FastStreamBuilder<String> builder = FastStream.builder();
FastStream.of(list).forEachOrderedIdx((e, i) -> builder.accept(i + 1 + "." + e));
Assert.assertEquals(Arrays.asList("1.dromara", "2.hutool", "3.sweet"), builder.build().toList());
FastStream.FastStreamBuilder<String> streamBuilder = FastStream.builder();
FastStream.of(list).parallel().forEachOrderedIdx((e, i) -> streamBuilder.accept(i + 1 + "." + e));
Assert.assertEquals(Arrays.asList("0.dromara", "0.hutool", "0.sweet"), streamBuilder.build().toList());
}
@Test
@@ -186,13 +204,22 @@ public class FastStreamTest {
}
@Test
public void testFlatMapIter() {
public void testFlat() {
List<Integer> list = Arrays.asList(1, 2, 3);
List<Integer> flatMapIter = FastStream.of(list).<Integer>flatMapIter(e -> null).toList();
Assert.assertEquals(Collections.emptyList(), flatMapIter);
flatMapIter = FastStream.of(list).flatMapIter(e -> Arrays.asList(e, e * 10)).toList();
Assert.assertEquals(ListUtil.of(1, 10, 2, 20, 3, 30), flatMapIter);
// 一个元素 扩散为 多个元素(迭代器)
List<Integer> flat = FastStream.of(list).flat(e -> Arrays.asList(e, e * 10)).toList();
Assert.assertEquals(ListUtil.of(1, 10, 2, 20, 3, 30), flat);
// 过滤迭代器为null的元素
flat = FastStream.of(list).<Integer>flat(e -> null).toList();
Assert.assertEquals(Collections.emptyList(), flat);
// 自动过滤null元素
flat = FastStream.of(list).flat(e -> Arrays.asList(e, e > 2 ? e : null)).toList();
Assert.assertEquals(ListUtil.of(1, null, 2, null, 3, 3), flat);
// 不报npe测试
Assert.assertTrue(FastStream.of(list).flat(e -> null).isEmpty());
}
@Test
@@ -229,6 +256,8 @@ public class FastStreamTest {
List<Integer> list = Arrays.asList(1, 2);
List<Integer> push = FastStream.of(list).push(3).toList();
Assert.assertEquals(Arrays.asList(1, 2, 3), push);
Assert.assertEquals(Arrays.asList(1, 2, 3, 4), FastStream.of(list).push(3, 4).toList());
}
@Test
@@ -236,15 +265,19 @@ public class FastStreamTest {
List<Integer> list = Arrays.asList(2, 3);
List<Integer> unshift = FastStream.of(list).unshift(1).toList();
Assert.assertEquals(Arrays.asList(1, 2, 3), unshift);
Assert.assertEquals(Arrays.asList(1, 2, 2, 3), FastStream.of(list).unshift(1, 2).toList());
}
@Test
public void testAt() {
List<Integer> list = Arrays.asList(1, 2, 3);
Assert.assertEquals(1, (Object) FastStream.of(list).at(0));
Assert.assertEquals(1, (Object) FastStream.of(list).at(-3));
Assert.assertEquals(3, (Object) FastStream.of(list).at(-1));
Assert.assertNull(FastStream.of(list).at(-4));
Assert.assertEquals(1, (Object) FastStream.of(list).at(0).orElse(null));
Assert.assertEquals(2, (Object) FastStream.of(list).at(1).orElse(null));
Assert.assertEquals(3, (Object) FastStream.of(list).at(2).orElse(null));
Assert.assertEquals(1, (Object) FastStream.of(list).at(-3).orElse(null));
Assert.assertEquals(3, (Object) FastStream.of(list).at(-1).orElse(null));
Assert.assertNull(FastStream.of(list).at(-4).orElse(null));
}
@Test
@@ -262,40 +295,55 @@ public class FastStreamTest {
@Test
public void testFindFirst() {
List<Integer> list = Arrays.asList(1, 2, 3);
Integer find = FastStream.of(list).findFirst(Objects::nonNull);
Integer find = FastStream.of(list).findFirst(Objects::nonNull).orElse(null);
Assert.assertEquals(1, (Object) find);
}
@Test
public void testFindFirstIdx() {
List<Integer> list = Arrays.asList(null, 2, 3);
Integer idx = FastStream.of(list).findFirstIdx(Objects::nonNull);
Assert.assertEquals(1, (Object) idx);
Assert.assertEquals(1, FastStream.of(list).findFirstIdx(Objects::nonNull));
Assert.assertEquals(-1, (Object) FastStream.of(list).parallel().findFirstIdx(Objects::nonNull));
}
@Test
public void testFindLast() {
List<Integer> list = ListUtil.of(1, null, 3);
Integer find = FastStream.of(list).parallel().findLast(Objects::nonNull);
Assert.assertEquals(3, (Object) find);
List<Integer> list = ListUtil.of(1, 2, 4, 5, 6, 7, 8, 9, 10, 3);
Assert.assertEquals(3, (Object) FastStream.of(list).findLast().orElse(null));
Assert.assertEquals(3, (Object) FastStream.of(list).parallel().findLast().orElse(null));
List<Integer> list2 = ListUtil.of(1, 2, 4, 5, 6, 7, 8, 9, 10, 3, null);
Assert.assertEquals(3, (Object) FastStream.of(list2).parallel().findLast(Objects::nonNull).orElse(null));
Assert.assertNull(FastStream.of().parallel().findLast(Objects::nonNull).orElse(null));
Assert.assertNull(FastStream.of((Object) null).parallel().findLast(Objects::nonNull).orElse(null));
}
@Test
public void testFindLastIdx() {
List<Integer> list = Arrays.asList(1, null, 3);
Integer idx = FastStream.of(list).findLastIdx(Objects::nonNull);
Assert.assertEquals(2, (Object) idx);
Assert.assertEquals(2, (Object) FastStream.of(list).findLastIdx(Objects::nonNull));
Assert.assertEquals(-1, (Object) FastStream.of(list).parallel().findLastIdx(Objects::nonNull));
}
@Test
public void testReverse() {
final List<Integer> list = ListUtil.of(Stream.iterate(1, i -> i + 1).limit(1000).collect(Collectors.toList()));
Assert.assertEquals(ListUtil.reverseNew(list), FastStream.of(list).reverse().toList());
Assert.assertEquals(ListUtil.empty(), FastStream.of().reverse().toList());
Assert.assertEquals(ListUtil.of((Object) null), FastStream.of((Object) null).reverse().toList());
}
@Test
public void testZip() {
List<Integer> orders = Arrays.asList(1, 2, 3);
List<String> list = Arrays.asList("dromara", "hutool", "sweet");
List<String> zip = FastStream.of(orders).zip(list, (e1, e2) -> e1 + "." + e2).toList();
Assert.assertEquals(Arrays.asList("1.dromara", "2.hutool", "3.sweet"), zip);
zip = FastStream.iterate(1, i -> i + 1).zip(list, (e1, e2) -> e1 + "." + e2).toList();
Assert.assertEquals(Arrays.asList("1.dromara", "2.hutool", "3.sweet"), zip);
}
@Test
@@ -319,4 +367,64 @@ public class FastStreamTest {
lists = FastStream.of(list).splitList(list.size()).toList();
Assert.assertEquals(singletonList(list), lists);
}
@Test
public void testTakeWhile() {
// 1 到 10
final List<Integer> list = FastStream.iterate(1, i -> i <= 10, i -> i + 1).toList();
final List<String> res1 = FastStream.of(list)
// 舍弃 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<Integer> res2 = FastStream.iterate(1, i -> i + 1)
.parallel()
.takeWhile(e -> e < 5)
.map(String::valueOf)
.map(Integer::valueOf)
.sorted(Comparator.naturalOrder())
.toList();
Assert.assertEquals(Arrays.asList(1, 2, 3, 4), res2);
}
@Test
public void testDropWhile() {
// 1 到 10
final List<Integer> list = FastStream.iterate(1, i -> i <= 10, i -> i + 1).toList();
final List<String> res1 = FastStream.of(list)
// 舍弃 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<Integer> res2 = FastStream.of(list)
.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);
}
@Test
public void testIsNotEmpty() {
Assert.assertTrue(FastStream.of(1).isNotEmpty());
}
}