From 18fff4ea8733ef42386ed392cce97a3eb4fe32fa Mon Sep 17 00:00:00 2001 From: emptypoint Date: Fri, 19 Aug 2022 20:06:56 +0800 Subject: [PATCH] =?UTF-8?q?=E4=BF=AE=E6=94=B9FastStream=E5=90=8D=E7=A7=B0?= =?UTF-8?q?=E4=B8=BAEasyStream;?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../{FastStream.java => EasyStream.java} | 170 ++++++++--------- ...astStreamTest.java => EasyStreamTest.java} | 172 +++++++++--------- 2 files changed, 171 insertions(+), 171 deletions(-) rename hutool-core/src/main/java/cn/hutool/core/stream/{FastStream.java => EasyStream.java} (90%) rename hutool-core/src/test/java/cn/hutool/core/stream/{FastStreamTest.java => EasyStreamTest.java} (63%) diff --git a/hutool-core/src/main/java/cn/hutool/core/stream/FastStream.java b/hutool-core/src/main/java/cn/hutool/core/stream/EasyStream.java similarity index 90% rename from hutool-core/src/main/java/cn/hutool/core/stream/FastStream.java rename to hutool-core/src/main/java/cn/hutool/core/stream/EasyStream.java index 22f266dfd..212196afa 100644 --- a/hutool-core/src/main/java/cn/hutool/core/stream/FastStream.java +++ b/hutool-core/src/main/java/cn/hutool/core/stream/EasyStream.java @@ -48,7 +48,7 @@ import java.util.stream.*; * @see java.util.stream.Stream * @since 6.0.0 */ -public class FastStream implements Stream, Iterable { +public class EasyStream implements Stream, Iterable { /** * 代表不存在的下标, 一般用于并行流的下标, 或者未找到元素时的下标 */ @@ -56,7 +56,7 @@ public class FastStream implements Stream, Iterable { protected final Stream stream; - FastStream(Stream stream) { + EasyStream(Stream stream) { this.stream = stream; } @@ -80,8 +80,8 @@ public class FastStream implements Stream, Iterable { } @Override - public FastStream build() { - return new FastStream<>(streamBuilder.build()); + public EasyStream build() { + return new EasyStream<>(streamBuilder.build()); } }; } @@ -92,8 +92,8 @@ public class FastStream implements Stream, Iterable { * @param 元素类型 * @return 一个空的串行流 */ - public static FastStream empty() { - return new FastStream<>(Stream.empty()); + public static EasyStream empty() { + return new EasyStream<>(Stream.empty()); } /** @@ -103,8 +103,8 @@ public class FastStream implements Stream, Iterable { * @param 元素类型 * @return 包含单个元素的串行流 */ - public static FastStream of(T t) { - return new FastStream<>(Stream.of(t)); + public static EasyStream of(T t) { + return new EasyStream<>(Stream.of(t)); } /** @@ -117,8 +117,8 @@ public class FastStream implements Stream, Iterable { */ @SafeVarargs @SuppressWarnings("varargs") - public static FastStream of(T... values) { - return ArrayUtil.isEmpty(values) ? FastStream.empty() : new FastStream<>(Stream.of(values)); + public static EasyStream of(T... values) { + return ArrayUtil.isEmpty(values) ? EasyStream.empty() : new EasyStream<>(Stream.of(values)); } /** @@ -127,7 +127,7 @@ public class FastStream implements Stream, Iterable { *

* 例如 * {@code FastStream.iterate(0, i -> i + 1)} - * 就可以创建从0开始，每次+1的无限流，使用{@link FastStream#limit(long)}可以限制元素个数 + * 就可以创建从0开始，每次+1的无限流，使用{@link EasyStream#limit(long)}可以限制元素个数 *

* * @param 元素类型 @@ -135,8 +135,8 @@ public class FastStream implements Stream, Iterable { * @param f 用上一个元素作为参数执行并返回一个新的元素 * @return 无限有序流 */ - public static FastStream iterate(final T seed, final UnaryOperator f) { - return new FastStream<>(Stream.iterate(seed, f)); + public static EasyStream iterate(final T seed, final UnaryOperator f) { + return new EasyStream<>(Stream.iterate(seed, f)); } /** @@ -145,7 +145,7 @@ public class FastStream implements Stream, Iterable { *

* 例如 * {@code FastStream.iterate(0, i -> i < 3, i -> ++i)} - * 就可以创建包含元素0,1,2的流，使用{@link FastStream#limit(long)}可以限制元素个数 + * 就可以创建包含元素0,1,2的流，使用{@link EasyStream#limit(long)}可以限制元素个数 *

* * @param 元素类型 @@ -154,10 +154,10 @@ public class FastStream implements Stream, Iterable { * @param next 用上一个元素作为参数执行并返回一个新的元素 * @return 无限有序流 */ - public static FastStream iterate(T seed, Predicate hasNext, UnaryOperator next) { + public static EasyStream iterate(T seed, Predicate hasNext, UnaryOperator next) { Objects.requireNonNull(next); Objects.requireNonNull(hasNext); - return new FastStream<>(StreamUtil.iterate(seed, hasNext, next)); + return new EasyStream<>(StreamUtil.iterate(seed, hasNext, next)); } /** @@ -169,8 +169,8 @@ public class FastStream implements Stream, Iterable { * @param s 用来生成元素的 {@code Supplier} * @return 无限串行无序流 */ - public static FastStream generate(Supplier s) { - return new FastStream<>(Stream.generate(s)); + public static EasyStream generate(Supplier s) { + return new EasyStream<>(Stream.generate(s)); } /** @@ -185,8 +185,8 @@ public class FastStream implements Stream, Iterable { * @param b 第二个流 * @return 拼接两个流之后的流 */ - public static FastStream concat(Stream a, Stream b) { - return new FastStream<>(Stream.concat(a, b)); + public static EasyStream concat(Stream a, Stream b) { + return new EasyStream<>(Stream.concat(a, b)); } /** @@ -196,7 +196,7 @@ public class FastStream implements Stream, Iterable { * @param 元素类型 * @return 流 */ - public static FastStream of(Iterable iterable) { + public static EasyStream of(Iterable iterable) { return of(iterable, false); } @@ -208,8 +208,8 @@ public class FastStream implements Stream, Iterable { * @param 元素类型 * @return 流 */ - public static FastStream of(Iterable iterable, boolean parallel) { - return Opt.ofNullable(iterable).map(Iterable::spliterator).map(spliterator -> StreamSupport.stream(spliterator, parallel)).map(FastStream::new).orElseGet(FastStream::empty); + public static EasyStream of(Iterable iterable, boolean parallel) { + return Opt.ofNullable(iterable).map(Iterable::spliterator).map(spliterator -> StreamSupport.stream(spliterator, parallel)).map(EasyStream::new).orElseGet(EasyStream::empty); } /** @@ -219,8 +219,8 @@ public class FastStream implements Stream, Iterable { * @param 元素类型 * @return 流 */ - public static FastStream of(Stream stream) { - return new FastStream<>(Objects.requireNonNull(stream)); + public static EasyStream of(Stream stream) { + return new EasyStream<>(Objects.requireNonNull(stream)); } /** @@ -230,8 +230,8 @@ public class FastStream implements Stream, Iterable { * @param regex 正则 * @return 拆分后元素组成的流 */ - public static FastStream split(CharSequence str, String regex) { - return Opt.ofBlankAble(str).map(CharSequence::toString).map(s -> s.split(regex)).map(FastStream::of).orElseGet(FastStream::empty); + public static EasyStream split(CharSequence str, String regex) { + return Opt.ofBlankAble(str).map(CharSequence::toString).map(s -> s.split(regex)).map(EasyStream::of).orElseGet(EasyStream::empty); } // --------------------------------------------------------------- Static method end @@ -245,8 +245,8 @@ public class FastStream implements Stream, Iterable { * @return 返回叠加过滤操作后的流 */ @Override - public FastStream filter(Predicate predicate) { - return new FastStream<>(stream.filter(predicate)); + public EasyStream filter(Predicate predicate) { + return new EasyStream<>(stream.filter(predicate)); } /** @@ -258,7 +258,7 @@ public class FastStream implements Stream, Iterable { * @param value 用来匹配的值 * @return 与 指定操作结果 匹配 指定值 的元素组成的流 */ - public FastStream filter(Function mapper, R value) { + public EasyStream filter(Function mapper, R value) { Objects.requireNonNull(mapper); return filter(e -> Objects.equals(mapper.apply(e), value)); } @@ -270,7 +270,7 @@ public class FastStream implements Stream, Iterable { * @param predicate 断言 * @return 返回叠加过滤操作后的流 */ - public FastStream filterIdx(BiPredicate predicate) { + public EasyStream filterIdx(BiPredicate predicate) { Objects.requireNonNull(predicate); if (isParallel()) { return filter(e -> predicate.test(e, NOT_FOUND_INDEX)); @@ -285,8 +285,8 @@ public class FastStream implements Stream, Iterable { * * @return 过滤后的流 */ - public FastStream nonNull() { - return new FastStream<>(stream.filter(Objects::nonNull)); + public EasyStream nonNull() { + return new EasyStream<>(stream.filter(Objects::nonNull)); } /** @@ -298,8 +298,8 @@ public class FastStream implements Stream, Iterable { * @return 返回叠加操作后的流 */ @Override - public FastStream map(Function mapper) { - return new FastStream<>(stream.map(mapper)); + public EasyStream map(Function mapper) { + return new EasyStream<>(stream.map(mapper)); } /** @@ -314,7 +314,7 @@ public class FastStream implements Stream, Iterable { * @param 函数执行后返回的类型 * @return 新元素组成的流 */ - public FastStream mapNonNull(Function mapper) { + public EasyStream mapNonNull(Function mapper) { return nonNull().map(mapper).nonNull(); } @@ -326,7 +326,7 @@ public class FastStream implements Stream, Iterable { * @param 函数执行后返回的类型 * @return 返回叠加操作后的流 */ - public FastStream mapIdx(BiFunction mapper) { + public EasyStream mapIdx(BiFunction mapper) { Objects.requireNonNull(mapper); if (isParallel()) { return map(e -> mapper.apply(e, NOT_FOUND_INDEX)); @@ -349,8 +349,8 @@ public class FastStream implements Stream, Iterable { * @return 返回叠加拆分操作后的流 */ @Override - public FastStream flatMap(Function> mapper) { - return new FastStream<>(stream.flatMap(mapper)); + public EasyStream flatMap(Function> mapper) { + return new EasyStream<>(stream.flatMap(mapper)); } /** @@ -361,7 +361,7 @@ public class FastStream implements Stream, Iterable { * @param 拆分后流的元素类型 * @return 返回叠加拆分操作后的流 */ - public FastStream flatMapIdx(BiFunction> mapper) { + public EasyStream flatMapIdx(BiFunction> mapper) { Objects.requireNonNull(mapper); if (isParallel()) { return flatMap(e -> mapper.apply(e, NOT_FOUND_INDEX)); @@ -372,7 +372,7 @@ public class FastStream implements Stream, Iterable { } /** - * 和{@link FastStream#map(Function)}一样，只不过函数的返回值必须为int类型 + * 和{@link EasyStream#map(Function)}一样，只不过函数的返回值必须为int类型 * 这是一个无状态中间操作 * * @param mapper 返回值为int类型的函数 @@ -384,7 +384,7 @@ public class FastStream implements Stream, Iterable { } /** - * 和{@link FastStream#map(Function)}一样，只不过函数的返回值必须为long类型 + * 和{@link EasyStream#map(Function)}一样，只不过函数的返回值必须为long类型 * 这是一个无状态中间操作 * * @param mapper 返回值为long类型的函数 @@ -396,7 +396,7 @@ public class FastStream implements Stream, Iterable { } /** - * 和{@link FastStream#map(Function)}一样，只不过函数的返回值必须为double类型 + * 和{@link EasyStream#map(Function)}一样，只不过函数的返回值必须为double类型 * 这是一个无状态中间操作 * * @param mapper 返回值为double类型的函数 @@ -420,7 +420,7 @@ public class FastStream implements Stream, Iterable { * @param 拆分后流的元素类型 * @return 返回叠加拆分操作后的流 */ - public FastStream flat(Function> mapper) { + public EasyStream flat(Function> mapper) { Objects.requireNonNull(mapper); return flatMap(w -> of(mapper.apply(w))); } @@ -436,7 +436,7 @@ public class FastStream implements Stream, Iterable { * @see #flat(Function) * @see #nonNull() */ - public FastStream flatNonNull(Function> mapper) { + public EasyStream flatNonNull(Function> mapper) { return nonNull().flat(mapper).nonNull(); } @@ -484,10 +484,10 @@ public class FastStream implements Stream, Iterable { * @param 拆分后流的元素类型 * @return 返回叠加拆分操作后的流 */ - public FastStream mapMulti(BiConsumer> mapper) { + public EasyStream mapMulti(BiConsumer> mapper) { Objects.requireNonNull(mapper); return flatMap(e -> { - FastStreamBuilder buffer = FastStream.builder(); + FastStreamBuilder buffer = EasyStream.builder(); mapper.accept(e, buffer); return buffer.build(); }); @@ -500,8 +500,8 @@ public class FastStream implements Stream, Iterable { * @return 一个具有去重特征的流 */ @Override - public FastStream distinct() { - return new FastStream<>(stream.distinct()); + public EasyStream distinct() { + return new EasyStream<>(stream.distinct()); } /** @@ -512,7 +512,7 @@ public class FastStream implements Stream, Iterable { * @param keyExtractor 去重依据 * @return 一个具有去重特征的流 */ - public FastStream distinct(Function keyExtractor) { + public EasyStream distinct(Function keyExtractor) { Objects.requireNonNull(keyExtractor); if (isParallel()) { ConcurrentHashMap exists = MapUtil.newConcurrentHashMap(); @@ -548,8 +548,8 @@ public class FastStream implements Stream, Iterable { * @return 一个元素按自然顺序排序的流 */ @Override - public FastStream sorted() { - return new FastStream<>(stream.sorted()); + public EasyStream sorted() { + return new EasyStream<>(stream.sorted()); } /** @@ -562,8 +562,8 @@ public class FastStream implements Stream, Iterable { * @return 一个元素按指定的Comparator排序的流 */ @Override - public FastStream sorted(Comparator comparator) { - return new FastStream<>(stream.sorted(comparator)); + public EasyStream sorted(Comparator comparator) { + return new EasyStream<>(stream.sorted(comparator)); } /** @@ -584,8 +584,8 @@ public class FastStream implements Stream, Iterable { * } */ @Override - public FastStream peek(Consumer action) { - return new FastStream<>(stream.peek(action)); + public EasyStream peek(Consumer action) { + return new EasyStream<>(stream.peek(action)); } /** @@ -593,7 +593,7 @@ public class FastStream implements Stream, Iterable { * * @return 返回叠加操作后的FastStream */ - public FastStream log() { + public EasyStream log() { return peek(Console::log); } @@ -605,8 +605,8 @@ public class FastStream implements Stream, Iterable { * @return 截取后的流 */ @Override - public FastStream limit(long maxSize) { - return new FastStream<>(stream.limit(maxSize)); + public EasyStream limit(long maxSize) { + return new EasyStream<>(stream.limit(maxSize)); } /** @@ -617,8 +617,8 @@ public class FastStream implements Stream, Iterable { * @return 丢弃前面n个元素后的剩余元素组成的流 */ @Override - public FastStream skip(long n) { - return new FastStream<>(stream.skip(n)); + public EasyStream skip(long n) { + return new EasyStream<>(stream.skip(n)); } /** @@ -627,7 +627,7 @@ public class FastStream implements Stream, Iterable { * @return 串行流 */ @Override - public FastStream sequential() { + public EasyStream sequential() { //noinspection ResultOfMethodCallIgnored stream.sequential(); return this; @@ -982,7 +982,7 @@ public class FastStream implements Stream, Iterable { * * @return 反转元素顺序 */ - public FastStream reverse() { + public EasyStream reverse() { //noinspection unchecked final T[] array = (T[]) toArray(); ArrayUtil.reverse(array); @@ -1025,7 +1025,7 @@ public class FastStream implements Stream, Iterable { * @return 并行流 */ @Override - public FastStream parallel() { + public EasyStream parallel() { //noinspection ResultOfMethodCallIgnored stream.parallel(); return this; @@ -1037,7 +1037,7 @@ public class FastStream implements Stream, Iterable { * @param parallel 是否并行 * @return 流 */ - public FastStream parallel(boolean parallel) { + public EasyStream parallel(boolean parallel) { return parallel ? parallel() : sequential(); } @@ -1048,8 +1048,8 @@ public class FastStream implements Stream, Iterable { * @return 无序流 */ @Override - public FastStream unordered() { - return new FastStream<>(stream.unordered()); + public EasyStream unordered() { + return new EasyStream<>(stream.unordered()); } /** @@ -1059,7 +1059,7 @@ public class FastStream implements Stream, Iterable { * @return 流 */ @Override - public FastStream onClose(Runnable closeHandler) { + public EasyStream onClose(Runnable closeHandler) { //noinspection ResultOfMethodCallIgnored stream.onClose(closeHandler); return this; @@ -1071,8 +1071,8 @@ public class FastStream implements Stream, Iterable { * @param obj 元素 * @return 流 */ - public FastStream push(T obj) { - return FastStream.concat(this.stream, of(obj)); + public EasyStream push(T obj) { + return EasyStream.concat(this.stream, of(obj)); } /** @@ -1082,8 +1082,8 @@ public class FastStream implements Stream, Iterable { * @return 流 */ @SuppressWarnings("unchecked") - public FastStream push(T... obj) { - return FastStream.concat(this.stream, of(obj)); + public EasyStream push(T... obj) { + return EasyStream.concat(this.stream, of(obj)); } /** @@ -1092,8 +1092,8 @@ public class FastStream implements Stream, Iterable { * @param obj 元素 * @return 流 */ - public FastStream unshift(T obj) { - return FastStream.concat(of(obj), this.stream); + public EasyStream unshift(T obj) { + return EasyStream.concat(of(obj), this.stream); } /** @@ -1103,8 +1103,8 @@ public class FastStream implements Stream, Iterable { * @return 流 */ @SafeVarargs - public final FastStream unshift(T... obj) { - return FastStream.concat(of(obj), this.stream); + public final EasyStream unshift(T... obj) { + return EasyStream.concat(of(obj), this.stream); } /** @@ -1377,7 +1377,7 @@ public class FastStream implements Stream, Iterable { * @param 合并后的结果对象类型 * @return 合并后的结果对象的流 */ - public FastStream zip(Iterable other, + public EasyStream zip(Iterable other, BiFunction zipper) { Objects.requireNonNull(zipper); final Spliterator keys = spliterator(); @@ -1406,7 +1406,7 @@ public class FastStream implements Stream, Iterable { * @return 操作后的流 */ @SafeVarargs - public final FastStream splice(int start, int deleteCount, T... items) { + public final EasyStream splice(int start, int deleteCount, T... items) { return of(ListUtil.splice(toList(), start, deleteCount, items)) .parallel(isParallel()) .onClose(stream::close); @@ -1421,13 +1421,13 @@ public class FastStream implements Stream, Iterable { * @param batchSize 指定长度, 正整数 * @return 切好的流 */ - public FastStream> split(final int batchSize) { + public EasyStream> split(final int batchSize) { List list = toList(); final int size = list.size(); // 指定长度 大于等于 列表长度 if (size <= batchSize) { // 返回第一层只有单个元素的双层流，形如：[[1,2,3,4,5]] - return FastStream.>of(of(list, isParallel())); + return EasyStream.>of(of(list, isParallel())); } return iterate(0, i -> i < size, i -> i + batchSize) .map(skip -> of(list.subList(skip, Math.min(size, skip + batchSize)), isParallel())) @@ -1444,8 +1444,8 @@ public class FastStream implements Stream, Iterable { * @param batchSize 指定长度, 正整数 * @return 切好的流 */ - public FastStream> splitList(final int batchSize) { - return split(batchSize).map(FastStream::toList); + public EasyStream> splitList(final int batchSize) { + return split(batchSize).map(EasyStream::toList); } /** @@ -1467,7 +1467,7 @@ public class FastStream implements Stream, Iterable { * @param predicate 断言 * @return 与指定断言匹配的元素组成的流 */ - public FastStream takeWhile(Predicate predicate) { + public EasyStream takeWhile(Predicate predicate) { Objects.requireNonNull(predicate); return of(StreamUtil.takeWhile(stream, predicate)); } @@ -1492,7 +1492,7 @@ public class FastStream implements Stream, Iterable { * @param predicate 断言 * @return 剩余元素组成的流 */ - public FastStream dropWhile(Predicate predicate) { + public EasyStream dropWhile(Predicate predicate) { Objects.requireNonNull(predicate); return of(StreamUtil.dropWhile(stream, predicate)); } @@ -1515,7 +1515,7 @@ public class FastStream implements Stream, Iterable { return !isEmpty(); } - public interface FastStreamBuilder extends Consumer, cn.hutool.core.builder.Builder> { + public interface FastStreamBuilder extends Consumer, cn.hutool.core.builder.Builder> { /** * Adds an element to the stream being built. diff --git a/hutool-core/src/test/java/cn/hutool/core/stream/FastStreamTest.java b/hutool-core/src/test/java/cn/hutool/core/stream/EasyStreamTest.java similarity index 63% rename from hutool-core/src/test/java/cn/hutool/core/stream/FastStreamTest.java rename to hutool-core/src/test/java/cn/hutool/core/stream/EasyStreamTest.java index e9d51b7c5..51f3262e3 100644 --- a/hutool-core/src/test/java/cn/hutool/core/stream/FastStreamTest.java +++ b/hutool-core/src/test/java/cn/hutool/core/stream/EasyStreamTest.java @@ -15,57 +15,57 @@ import static java.util.Collections.singletonList; /** * @author VampireAchao */ -public class FastStreamTest { +public class EasyStreamTest { @Test public void testBuilder() { - List list = FastStream.builder().add(1).add(2).add(3).build().toList(); + List list = EasyStream.builder().add(1).add(2).add(3).build().toList(); Assert.assertEquals(Arrays.asList(1, 2, 3), list); } @Test public void testGenerate() { - List list = FastStream.generate(() -> 0).limit(3).toList(); + List list = EasyStream.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()); - Assert.assertEquals(3, FastStream.of(1, 2, 3).count()); - Assert.assertEquals(3, FastStream.of(Stream.builder().add(1).add(2).add(3).build()).count()); + Assert.assertEquals(3, EasyStream.of(Arrays.asList(1, 2, 3), true).count()); + Assert.assertEquals(3, EasyStream.of(1, 2, 3).count()); + Assert.assertEquals(3, EasyStream.of(Stream.builder().add(1).add(2).add(3).build()).count()); } @Test public void testSplit() { - List list = FastStream.split("1,2,3", ",").map(Integer::valueOf).toList(); + List list = EasyStream.split("1,2,3", ",").map(Integer::valueOf).toList(); Assert.assertEquals(Arrays.asList(1, 2, 3), list); } @Test public void testIterator() { - List list = FastStream.iterate(0, i -> i < 3, i -> ++i).toList(); + List list = EasyStream.iterate(0, i -> i < 3, i -> ++i).toList(); Assert.assertEquals(Arrays.asList(0, 1, 2), list); } @Test public void testToCollection() { List list = Arrays.asList(1, 2, 3); - List toCollection = FastStream.of(list).map(String::valueOf).toColl(LinkedList::new); + List toCollection = EasyStream.of(list).map(String::valueOf).toColl(LinkedList::new); Assert.assertEquals(Arrays.asList("1", "2", "3"), toCollection); } @Test public void testToList() { List list = Arrays.asList(1, 2, 3); - List toList = FastStream.of(list).map(String::valueOf).toList(); + List toList = EasyStream.of(list).map(String::valueOf).toList(); Assert.assertEquals(Arrays.asList("1", "2", "3"), toList); } @Test public void testToSet() { List list = Arrays.asList(1, 2, 3); - Set toSet = FastStream.of(list).map(String::valueOf).toSet(); + Set toSet = EasyStream.of(list).map(String::valueOf).toSet(); Assert.assertEquals(new HashSet<>(Arrays.asList("1", "2", "3")), toSet); } @@ -79,26 +79,26 @@ public class FastStreamTest { .put(3, "sweet") .build(); - Map toZip = FastStream.of(orders).toZip(list); + Map toZip = EasyStream.of(orders).toZip(list); Assert.assertEquals(map, toZip); - Map toZipParallel = FastStream.of(orders).parallel().nonNull().toZip(list); + Map toZipParallel = EasyStream.of(orders).parallel().nonNull().toZip(list); Assert.assertEquals(map, toZipParallel); } @Test public void testJoin() { List list = Arrays.asList(1, 2, 3); - String joining = FastStream.of(list).join(); + String joining = EasyStream.of(list).join(); Assert.assertEquals("123", joining); - Assert.assertEquals("1,2,3", FastStream.of(list).join(",")); - Assert.assertEquals("(1,2,3)", FastStream.of(list).join(",", "(", ")")); + Assert.assertEquals("1,2,3", EasyStream.of(list).join(",")); + Assert.assertEquals("(1,2,3)", EasyStream.of(list).join(",", "(", ")")); } @Test public void testToMap() { List list = Arrays.asList(1, 2, 3); - Map identityMap = FastStream.of(list).toMap(String::valueOf); + Map identityMap = EasyStream.of(list).toMap(String::valueOf); Assert.assertEquals(new HashMap() { private static final long serialVersionUID = 1L; @@ -113,7 +113,7 @@ public class FastStreamTest { @Test public void testGroup() { List list = Arrays.asList(1, 2, 3); - Map> group = FastStream.of(list).group(String::valueOf); + Map> group = EasyStream.of(list).group(String::valueOf); Assert.assertEquals( new HashMap>() { private static final long serialVersionUID = 1L; @@ -129,16 +129,16 @@ public class FastStreamTest { @Test public void testMapIdx() { List list = Arrays.asList("dromara", "hutool", "sweet"); - List mapIndex = FastStream.of(list).mapIdx((e, i) -> i + 1 + "." + e).toList(); + List mapIndex = EasyStream.of(list).mapIdx((e, i) -> i + 1 + "." + e).toList(); Assert.assertEquals(Arrays.asList("1.dromara", "2.hutool", "3.sweet"), mapIndex); // 并行流时为-1 - Assert.assertEquals(Arrays.asList(-1, -1, -1), FastStream.of(1, 2, 3).parallel().mapIdx((e, i) -> i).toList()); + Assert.assertEquals(Arrays.asList(-1, -1, -1), EasyStream.of(1, 2, 3).parallel().mapIdx((e, i) -> i).toList()); } @Test public void testMapMulti() { List list = Arrays.asList(1, 2, 3); - List mapMulti = FastStream.of(list).mapMulti((e, buffer) -> { + List mapMulti = EasyStream.of(list).mapMulti((e, buffer) -> { for (int i = 0; i < e; i++) { buffer.accept(e); } @@ -149,7 +149,7 @@ public class FastStreamTest { @Test public void testMapNonNull() { List list = Arrays.asList(1, 2, 3, null); - List mapNonNull = FastStream.of(list).mapNonNull(String::valueOf).toList(); + List mapNonNull = EasyStream.of(list).mapNonNull(String::valueOf).toList(); Assert.assertEquals(Arrays.asList("1", "2", "3"), mapNonNull); } @@ -164,8 +164,8 @@ public class FastStreamTest { List collect2 = list.stream().parallel().distinct().collect(Collectors.toList()); // 使用FastStream去重 - List distinctBy1 = FastStream.of(list).distinct().toList(); - List distinctBy2 = FastStream.of(list).parallel().distinct(String::valueOf).toList(); + List distinctBy1 = EasyStream.of(list).distinct().toList(); + List distinctBy2 = EasyStream.of(list).parallel().distinct(String::valueOf).toList(); Assert.assertEquals(collect1, distinctBy1); Assert.assertEquals(collect2, distinctBy2); @@ -174,22 +174,22 @@ public class FastStreamTest { @Test public void testForeachIdx() { List list = Arrays.asList("dromara", "hutool", "sweet"); - FastStream.FastStreamBuilder builder = FastStream.builder(); - FastStream.of(list).forEachIdx((e, i) -> builder.accept(i + 1 + "." + e)); + EasyStream.FastStreamBuilder builder = EasyStream.builder(); + EasyStream.of(list).forEachIdx((e, i) -> builder.accept(i + 1 + "." + e)); Assert.assertEquals(Arrays.asList("1.dromara", "2.hutool", "3.sweet"), builder.build().toList()); // 并行流时为-1 - FastStream.of(1, 2, 3).parallel().forEachIdx((e, i) -> Assert.assertEquals(-1, (Object) i)); + EasyStream.of(1, 2, 3).parallel().forEachIdx((e, i) -> Assert.assertEquals(-1, (Object) i)); } @Test public void testForEachOrderedIdx() { List list = Arrays.asList("dromara", "hutool", "sweet"); - FastStream.FastStreamBuilder builder = FastStream.builder(); - FastStream.of(list).forEachOrderedIdx((e, i) -> builder.accept(i + 1 + "." + e)); + EasyStream.FastStreamBuilder builder = EasyStream.builder(); + EasyStream.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 streamBuilder = FastStream.builder(); - FastStream.of(list).parallel().forEachOrderedIdx((e, i) -> streamBuilder.accept(i + 1 + "." + e)); + EasyStream.FastStreamBuilder streamBuilder = EasyStream.builder(); + EasyStream.of(list).parallel().forEachOrderedIdx((e, i) -> streamBuilder.accept(i + 1 + "." + e)); Assert.assertEquals(Arrays.asList("0.dromara", "0.hutool", "0.sweet"), streamBuilder.build().toList()); } @@ -197,10 +197,10 @@ public class FastStreamTest { @Test public void testFlatMapIdx() { List list = Arrays.asList("dromara", "hutool", "sweet"); - List mapIndex = FastStream.of(list).flatMapIdx((e, i) -> FastStream.of(i + 1 + "." + e)).toList(); + List mapIndex = EasyStream.of(list).flatMapIdx((e, i) -> EasyStream.of(i + 1 + "." + e)).toList(); Assert.assertEquals(Arrays.asList("1.dromara", "2.hutool", "3.sweet"), mapIndex); // 并行流时为-1 - Assert.assertEquals(Arrays.asList(-1, -1, -1), FastStream.of(1, 2, 3).parallel().flatMapIdx((e, i) -> FastStream.of(i)).toList()); + Assert.assertEquals(Arrays.asList(-1, -1, -1), EasyStream.of(1, 2, 3).parallel().flatMapIdx((e, i) -> EasyStream.of(i)).toList()); } @Test @@ -208,172 +208,172 @@ public class FastStreamTest { List list = Arrays.asList(1, 2, 3); // 一个元素 扩散为 多个元素(迭代器) - List flat = FastStream.of(list).flat(e -> Arrays.asList(e, e * 10)).toList(); + List flat = EasyStream.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).flat(e -> null).toList(); + flat = EasyStream.of(list).flat(e -> null).toList(); Assert.assertEquals(Collections.emptyList(), flat); // 自动过滤null元素 - flat = FastStream.of(list).flat(e -> Arrays.asList(e, e > 2 ? e : null)).toList(); + flat = EasyStream.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()); + Assert.assertTrue(EasyStream.of(list).flat(e -> null).isEmpty()); } @Test public void testFilter() { List list = Arrays.asList(1, 2, 3); - List filterIndex = FastStream.of(list).filter(String::valueOf, "1").toList(); + List filterIndex = EasyStream.of(list).filter(String::valueOf, "1").toList(); Assert.assertEquals(Collections.singletonList(1), filterIndex); } @Test public void testFilterIdx() { List list = Arrays.asList("dromara", "hutool", "sweet"); - List filterIndex = FastStream.of(list).filterIdx((e, i) -> i < 2).toList(); + List filterIndex = EasyStream.of(list).filterIdx((e, i) -> i < 2).toList(); Assert.assertEquals(Arrays.asList("dromara", "hutool"), filterIndex); // 并行流时为-1 - Assert.assertEquals(3L, FastStream.of(1, 2, 3).parallel().filterIdx((e, i) -> i == -1).count()); + Assert.assertEquals(3L, EasyStream.of(1, 2, 3).parallel().filterIdx((e, i) -> i == -1).count()); } @Test public void testNonNull() { List list = Arrays.asList(1, null, 2, 3); - List nonNull = FastStream.of(list).nonNull().toList(); + List nonNull = EasyStream.of(list).nonNull().toList(); Assert.assertEquals(Arrays.asList(1, 2, 3), nonNull); } @Test public void testParallel() { - Assert.assertTrue(FastStream.of(1, 2, 3).parallel(true).isParallel()); - Assert.assertFalse(FastStream.of(1, 2, 3).parallel(false).isParallel()); + Assert.assertTrue(EasyStream.of(1, 2, 3).parallel(true).isParallel()); + Assert.assertFalse(EasyStream.of(1, 2, 3).parallel(false).isParallel()); } @Test public void testPush() { List list = Arrays.asList(1, 2); - List push = FastStream.of(list).push(3).toList(); + List push = EasyStream.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()); + Assert.assertEquals(Arrays.asList(1, 2, 3, 4), EasyStream.of(list).push(3, 4).toList()); } @Test public void testUnshift() { List list = Arrays.asList(2, 3); - List unshift = FastStream.of(list).unshift(1).toList(); + List unshift = EasyStream.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()); + Assert.assertEquals(Arrays.asList(1, 2, 2, 3), EasyStream.of(list).unshift(1, 2).toList()); } @Test public void testAt() { List list = Arrays.asList(1, 2, 3); - 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)); + Assert.assertEquals(1, (Object) EasyStream.of(list).at(0).orElse(null)); + Assert.assertEquals(2, (Object) EasyStream.of(list).at(1).orElse(null)); + Assert.assertEquals(3, (Object) EasyStream.of(list).at(2).orElse(null)); + Assert.assertEquals(1, (Object) EasyStream.of(list).at(-3).orElse(null)); + Assert.assertEquals(3, (Object) EasyStream.of(list).at(-1).orElse(null)); + Assert.assertNull(EasyStream.of(list).at(-4).orElse(null)); } @Test public void testSplice() { List list = Arrays.asList(1, 2, 3); - Assert.assertEquals(Arrays.asList(1, 2, 2, 3), FastStream.of(list).splice(1, 0, 2).toList()); - Assert.assertEquals(Arrays.asList(1, 2, 3, 3), FastStream.of(list).splice(3, 1, 3).toList()); - Assert.assertEquals(Arrays.asList(1, 2, 4), FastStream.of(list).splice(2, 1, 4).toList()); - Assert.assertEquals(Arrays.asList(1, 2), FastStream.of(list).splice(2, 1).toList()); - Assert.assertEquals(Arrays.asList(1, 2, 3), FastStream.of(list).splice(2, 0).toList()); - Assert.assertEquals(Arrays.asList(1, 2), FastStream.of(list).splice(-1, 1).toList()); - Assert.assertEquals(Arrays.asList(1, 2, 3), FastStream.of(list).splice(-2, 2, 2, 3).toList()); + Assert.assertEquals(Arrays.asList(1, 2, 2, 3), EasyStream.of(list).splice(1, 0, 2).toList()); + Assert.assertEquals(Arrays.asList(1, 2, 3, 3), EasyStream.of(list).splice(3, 1, 3).toList()); + Assert.assertEquals(Arrays.asList(1, 2, 4), EasyStream.of(list).splice(2, 1, 4).toList()); + Assert.assertEquals(Arrays.asList(1, 2), EasyStream.of(list).splice(2, 1).toList()); + Assert.assertEquals(Arrays.asList(1, 2, 3), EasyStream.of(list).splice(2, 0).toList()); + Assert.assertEquals(Arrays.asList(1, 2), EasyStream.of(list).splice(-1, 1).toList()); + Assert.assertEquals(Arrays.asList(1, 2, 3), EasyStream.of(list).splice(-2, 2, 2, 3).toList()); } @Test public void testFindFirst() { List list = Arrays.asList(1, 2, 3); - Integer find = FastStream.of(list).findFirst(Objects::nonNull).orElse(null); + Integer find = EasyStream.of(list).findFirst(Objects::nonNull).orElse(null); Assert.assertEquals(1, (Object) find); } @Test public void testFindFirstIdx() { List list = Arrays.asList(null, 2, 3); - Assert.assertEquals(1, FastStream.of(list).findFirstIdx(Objects::nonNull)); - Assert.assertEquals(-1, (Object) FastStream.of(list).parallel().findFirstIdx(Objects::nonNull)); + Assert.assertEquals(1, EasyStream.of(list).findFirstIdx(Objects::nonNull)); + Assert.assertEquals(-1, (Object) EasyStream.of(list).parallel().findFirstIdx(Objects::nonNull)); } @Test public void testFindLast() { List 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)); + Assert.assertEquals(3, (Object) EasyStream.of(list).findLast().orElse(null)); + Assert.assertEquals(3, (Object) EasyStream.of(list).parallel().findLast().orElse(null)); List 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.assertEquals(3, (Object) EasyStream.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)); + Assert.assertNull(EasyStream.of().parallel().findLast(Objects::nonNull).orElse(null)); + Assert.assertNull(EasyStream.of((Object) null).parallel().findLast(Objects::nonNull).orElse(null)); } @Test public void testFindLastIdx() { List list = Arrays.asList(1, null, 3); - Assert.assertEquals(2, (Object) FastStream.of(list).findLastIdx(Objects::nonNull)); - Assert.assertEquals(-1, (Object) FastStream.of(list).parallel().findLastIdx(Objects::nonNull)); + Assert.assertEquals(2, (Object) EasyStream.of(list).findLastIdx(Objects::nonNull)); + Assert.assertEquals(-1, (Object) EasyStream.of(list).parallel().findLastIdx(Objects::nonNull)); } @Test public void testReverse() { final List 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()); + Assert.assertEquals(ListUtil.reverseNew(list), EasyStream.of(list).reverse().toList()); + Assert.assertEquals(ListUtil.empty(), EasyStream.of().reverse().toList()); + Assert.assertEquals(ListUtil.of((Object) null), EasyStream.of((Object) null).reverse().toList()); } @Test public void testZip() { List orders = Arrays.asList(1, 2, 3); List list = Arrays.asList("dromara", "hutool", "sweet"); - List zip = FastStream.of(orders).zip(list, (e1, e2) -> e1 + "." + e2).toList(); + List zip = EasyStream.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(); + zip = EasyStream.iterate(1, i -> i + 1).zip(list, (e1, e2) -> e1 + "." + e2).toList(); Assert.assertEquals(Arrays.asList("1.dromara", "2.hutool", "3.sweet"), zip); } @Test public void testListSplit() { List list = Arrays.asList(1, 2, 3, 4, 5); - List> lists = FastStream.of(list).split(2).map(FastStream::toList).toList(); + List> lists = EasyStream.of(list).split(2).map(EasyStream::toList).toList(); Assert.assertEquals(ListUtil.split(list, 2), lists); // 指定长度 大于等于 列表长度 - lists = FastStream.of(list).split(list.size()).map(FastStream::toList).toList(); + lists = EasyStream.of(list).split(list.size()).map(EasyStream::toList).toList(); Assert.assertEquals(singletonList(list), lists); } @Test public void testSplitList() { List list = Arrays.asList(1, 2, 3, 4, 5); - List> lists = FastStream.of(list).splitList(2).toList(); + List> lists = EasyStream.of(list).splitList(2).toList(); Assert.assertEquals(ListUtil.split(list, 2), lists); // 指定长度 大于等于 列表长度 - lists = FastStream.of(list).splitList(list.size()).toList(); + lists = EasyStream.of(list).splitList(list.size()).toList(); Assert.assertEquals(singletonList(list), lists); } @Test public void testTakeWhile() { // 1 到 10 - final List list = FastStream.iterate(1, i -> i <= 10, i -> i + 1).toList(); + final List list = EasyStream.iterate(1, i -> i <= 10, i -> i + 1).toList(); - final List res1 = FastStream.of(list) + final List res1 = EasyStream.of(list) // 舍弃 5 .takeWhile(e -> e < 5) // 过滤奇数 @@ -384,7 +384,7 @@ public class FastStreamTest { .toList(); Assert.assertEquals(Arrays.asList("4", "2"), res1); - final List res2 = FastStream.iterate(1, i -> i + 1) + final List res2 = EasyStream.iterate(1, i -> i + 1) .parallel() .takeWhile(e -> e < 5) .map(String::valueOf) @@ -397,9 +397,9 @@ public class FastStreamTest { @Test public void testDropWhile() { // 1 到 10 - final List list = FastStream.iterate(1, i -> i <= 10, i -> i + 1).toList(); + final List list = EasyStream.iterate(1, i -> i <= 10, i -> i + 1).toList(); - final List res1 = FastStream.of(list) + final List res1 = EasyStream.of(list) // 舍弃 5之前的数字 .dropWhile(e -> e < 5) // 过滤偶数 @@ -410,7 +410,7 @@ public class FastStreamTest { .toList(); Assert.assertEquals(Arrays.asList("9", "7", "5"), res1); - final List res2 = FastStream.of(list) + final List res2 = EasyStream.of(list) .parallel() .dropWhile(e -> e < 5) // 过滤偶数 @@ -424,7 +424,7 @@ public class FastStreamTest { @Test public void testIsNotEmpty() { - Assert.assertTrue(FastStream.of(1).isNotEmpty()); + Assert.assertTrue(EasyStream.of(1).isNotEmpty()); } }