ZhouXY108/hutool
1
0
Fork 0
mirror of https://gitee.com/chinabugotech/hutool.git synced 2025-04-19 03:01:48 +08:00
Code Issues Packages Projects Releases Wiki Activity

修改FastStream名称为EasyStream;

Browse Source
This commit is contained in:
emptypoint 2022-08-19 20:06:56 +08:00
parent 0842ff0f50
commit 18fff4ea87
2 changed files with 171 additions and 171 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

170
hutool-core/src/main/java/cn/hutool/core/stream/FastStream.java → hutool-core/src/main/java/cn/hutool/core/stream/EasyStream.java
View File

@ -48,7 +48,7 @@ import java.util.stream.*;
* @see java.util.stream.Stream * @see java.util.stream.Stream
* @since 6.0.0 * @since 6.0.0
*/ */
public class FastStream<T> implements Stream<T>, Iterable<T> { public class EasyStream<T> implements Stream<T>, Iterable<T> {
/** /**
* 代表不存在的下标, 一般用于并行流的下标, 或者未找到元素时的下标 * 代表不存在的下标, 一般用于并行流的下标, 或者未找到元素时的下标
*/ */
@ -56,7 +56,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
protected final Stream<T> stream; protected final Stream<T> stream;
FastStream(Stream<T> stream) { EasyStream(Stream<T> stream) {
this.stream = stream; this.stream = stream;
} }
@ -80,8 +80,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
} }
@Override @Override
public FastStream<T> build() { public EasyStream<T> build() {
return new FastStream<>(streamBuilder.build()); return new EasyStream<>(streamBuilder.build());
} }
}; };
} }
@ -92,8 +92,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @param <T> 元素类型 * @param <T> 元素类型
* @return 一个空的串行流 * @return 一个空的串行流
*/ */
public static <T> FastStream<T> empty() { public static <T> EasyStream<T> empty() {
return new FastStream<>(Stream.empty()); return new EasyStream<>(Stream.empty());
} }
/** /**
@ -103,8 +103,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @param <T> 元素类型 * @param <T> 元素类型
* @return 包含单个元素的串行流 * @return 包含单个元素的串行流
*/ */
public static <T> FastStream<T> of(T t) { public static <T> EasyStream<T> of(T t) {
return new FastStream<>(Stream.of(t)); return new EasyStream<>(Stream.of(t));
} }
/** /**
@ -117,8 +117,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
*/ */
@SafeVarargs @SafeVarargs
@SuppressWarnings("varargs") @SuppressWarnings("varargs")
public static <T> FastStream<T> of(T... values) { public static <T> EasyStream<T> of(T... values) {
return ArrayUtil.isEmpty(values) ? FastStream.empty() : new FastStream<>(Stream.of(values)); return ArrayUtil.isEmpty(values) ? EasyStream.empty() : new EasyStream<>(Stream.of(values));
} }
/** /**
@ -127,7 +127,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* <p> * <p>
* 例如 * 例如
* {@code FastStream.iterate(0, i -> i + 1)} * {@code FastStream.iterate(0, i -> i + 1)}
* 就可以创建从0开始，每次+1的无限流，使用{@link FastStream#limit(long)}可以限制元素个数 * 就可以创建从0开始，每次+1的无限流，使用{@link EasyStream#limit(long)}可以限制元素个数
* </p> * </p>
* *
* @param <T> 元素类型 * @param <T> 元素类型
@ -135,8 +135,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @param f 用上一个元素作为参数执行并返回一个新的元素 * @param f 用上一个元素作为参数执行并返回一个新的元素
* @return 无限有序流 * @return 无限有序流
*/ */
public static <T> FastStream<T> iterate(final T seed, final UnaryOperator<T> f) { public static <T> EasyStream<T> iterate(final T seed, final UnaryOperator<T> f) {
return new FastStream<>(Stream.iterate(seed, f)); return new EasyStream<>(Stream.iterate(seed, f));
} }
/** /**
@ -145,7 +145,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* <p> * <p>
* 例如 * 例如
* {@code FastStream.iterate(0, i -> i < 3, i -> ++i)} * {@code FastStream.iterate(0, i -> i < 3, i -> ++i)}
* 就可以创建包含元素0,1,2的流，使用{@link FastStream#limit(long)}可以限制元素个数 * 就可以创建包含元素0,1,2的流，使用{@link EasyStream#limit(long)}可以限制元素个数
* </p> * </p>
* *
* @param <T> 元素类型 * @param <T> 元素类型
@ -154,10 +154,10 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @param next 用上一个元素作为参数执行并返回一个新的元素 * @param next 用上一个元素作为参数执行并返回一个新的元素
* @return 无限有序流 * @return 无限有序流
*/ */
public static <T> FastStream<T> iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next) { public static <T> EasyStream<T> iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next) {
Objects.requireNonNull(next); Objects.requireNonNull(next);
Objects.requireNonNull(hasNext); 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<T> implements Stream<T>, Iterable<T> {
* @param s 用来生成元素的 {@code Supplier} * @param s 用来生成元素的 {@code Supplier}
* @return 无限串行无序流 * @return 无限串行无序流
*/ */
public static <T> FastStream<T> generate(Supplier<T> s) { public static <T> EasyStream<T> generate(Supplier<T> s) {
return new FastStream<>(Stream.generate(s)); return new EasyStream<>(Stream.generate(s));
} }
/** /**
@ -185,8 +185,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @param b 第二个流 * @param b 第二个流
* @return 拼接两个流之后的流 * @return 拼接两个流之后的流
*/ */
public static <T> FastStream<T> concat(Stream<? extends T> a, Stream<? extends T> b) { public static <T> EasyStream<T> concat(Stream<? extends T> a, Stream<? extends T> b) {
return new FastStream<>(Stream.concat(a, b)); return new EasyStream<>(Stream.concat(a, b));
} }
/** /**
@ -196,7 +196,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @param <T> 元素类型 * @param <T> 元素类型
* @return 流 * @return 流
*/ */
public static <T> FastStream<T> of(Iterable<T> iterable) { public static <T> EasyStream<T> of(Iterable<T> iterable) {
return of(iterable, false); return of(iterable, false);
} }
@ -208,8 +208,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @param <T> 元素类型 * @param <T> 元素类型
* @return 流 * @return 流
*/ */
public static <T> FastStream<T> of(Iterable<T> iterable, boolean parallel) { public static <T> EasyStream<T> of(Iterable<T> iterable, boolean parallel) {
return Opt.ofNullable(iterable).map(Iterable::spliterator).map(spliterator -> StreamSupport.stream(spliterator, parallel)).map(FastStream::new).orElseGet(FastStream::empty); 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<T> implements Stream<T>, Iterable<T> {
* @param <T> 元素类型 * @param <T> 元素类型
* @return 流 * @return 流
*/ */
public static <T> FastStream<T> of(Stream<T> stream) { public static <T> EasyStream<T> of(Stream<T> stream) {
return new FastStream<>(Objects.requireNonNull(stream)); return new EasyStream<>(Objects.requireNonNull(stream));
} }
/** /**
@ -230,8 +230,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @param regex 正则 * @param regex 正则
* @return 拆分后元素组成的流 * @return 拆分后元素组成的流
*/ */
public static FastStream<String> split(CharSequence str, String regex) { public static EasyStream<String> split(CharSequence str, String regex) {
return Opt.ofBlankAble(str).map(CharSequence::toString).map(s -> s.split(regex)).map(FastStream::of).orElseGet(FastStream::empty); return Opt.ofBlankAble(str).map(CharSequence::toString).map(s -> s.split(regex)).map(EasyStream::of).orElseGet(EasyStream::empty);
} }
// --------------------------------------------------------------- Static method end // --------------------------------------------------------------- Static method end
@ -245,8 +245,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @return 返回叠加过滤操作后的流 * @return 返回叠加过滤操作后的流
*/ */
@Override @Override
public FastStream<T> filter(Predicate<? super T> predicate) { public EasyStream<T> filter(Predicate<? super T> predicate) {
return new FastStream<>(stream.filter(predicate)); return new EasyStream<>(stream.filter(predicate));
} }
/** /**
@ -258,7 +258,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @param value 用来匹配的值 * @param value 用来匹配的值
* @return 与 指定操作结果 匹配 指定值 的元素组成的流 * @return 与 指定操作结果 匹配 指定值 的元素组成的流
*/ */
public <R> FastStream<T> filter(Function<? super T, ? extends R> mapper, R value) { public <R> EasyStream<T> filter(Function<? super T, ? extends R> mapper, R value) {
Objects.requireNonNull(mapper); Objects.requireNonNull(mapper);
return filter(e -> Objects.equals(mapper.apply(e), value)); return filter(e -> Objects.equals(mapper.apply(e), value));
} }
@ -270,7 +270,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @param predicate 断言 * @param predicate 断言
* @return 返回叠加过滤操作后的流 * @return 返回叠加过滤操作后的流
*/ */
public FastStream<T> filterIdx(BiPredicate<? super T, Integer> predicate) { public EasyStream<T> filterIdx(BiPredicate<? super T, Integer> predicate) {
Objects.requireNonNull(predicate); Objects.requireNonNull(predicate);
if (isParallel()) { if (isParallel()) {
return filter(e -> predicate.test(e, NOT_FOUND_INDEX)); return filter(e -> predicate.test(e, NOT_FOUND_INDEX));
@ -285,8 +285,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* *
* @return 过滤后的流 * @return 过滤后的流
*/ */
public FastStream<T> nonNull() { public EasyStream<T> nonNull() {
return new FastStream<>(stream.filter(Objects::nonNull)); return new EasyStream<>(stream.filter(Objects::nonNull));
} }
/** /**
@ -298,8 +298,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @return 返回叠加操作后的流 * @return 返回叠加操作后的流
*/ */
@Override @Override
public <R> FastStream<R> map(Function<? super T, ? extends R> mapper) { public <R> EasyStream<R> map(Function<? super T, ? extends R> mapper) {
return new FastStream<>(stream.map(mapper)); return new EasyStream<>(stream.map(mapper));
} }
/** /**
@ -314,7 +314,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @param <R> 函数执行后返回的类型 * @param <R> 函数执行后返回的类型
* @return 新元素组成的流 * @return 新元素组成的流
*/ */
public <R> FastStream<R> mapNonNull(Function<? super T, ? extends R> mapper) { public <R> EasyStream<R> mapNonNull(Function<? super T, ? extends R> mapper) {
return nonNull().<R>map(mapper).nonNull(); return nonNull().<R>map(mapper).nonNull();
} }
@ -326,7 +326,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @param <R> 函数执行后返回的类型 * @param <R> 函数执行后返回的类型
* @return 返回叠加操作后的流 * @return 返回叠加操作后的流
*/ */
public <R> FastStream<R> mapIdx(BiFunction<? super T, Integer, ? extends R> mapper) { public <R> EasyStream<R> mapIdx(BiFunction<? super T, Integer, ? extends R> mapper) {
Objects.requireNonNull(mapper); Objects.requireNonNull(mapper);
if (isParallel()) { if (isParallel()) {
return map(e -> mapper.apply(e, NOT_FOUND_INDEX)); return map(e -> mapper.apply(e, NOT_FOUND_INDEX));
@ -349,8 +349,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @return 返回叠加拆分操作后的流 * @return 返回叠加拆分操作后的流
*/ */
@Override @Override
public <R> FastStream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper) { public <R> EasyStream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper) {
return new FastStream<>(stream.flatMap(mapper)); return new EasyStream<>(stream.flatMap(mapper));
} }
/** /**
@ -361,7 +361,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @param <R> 拆分后流的元素类型 * @param <R> 拆分后流的元素类型
* @return 返回叠加拆分操作后的流 * @return 返回叠加拆分操作后的流
*/ */
public <R> FastStream<R> flatMapIdx(BiFunction<? super T, Integer, ? extends Stream<? extends R>> mapper) { public <R> EasyStream<R> flatMapIdx(BiFunction<? super T, Integer, ? extends Stream<? extends R>> mapper) {
Objects.requireNonNull(mapper); Objects.requireNonNull(mapper);
if (isParallel()) { if (isParallel()) {
return flatMap(e -> mapper.apply(e, NOT_FOUND_INDEX)); return flatMap(e -> mapper.apply(e, NOT_FOUND_INDEX));
@ -372,7 +372,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
} }
/** /**
* 和{@link FastStream#map(Function)}一样，只不过函数的返回值必须为int类型 * 和{@link EasyStream#map(Function)}一样，只不过函数的返回值必须为int类型
* 这是一个无状态中间操作 * 这是一个无状态中间操作
* *
* @param mapper 返回值为int类型的函数 * @param mapper 返回值为int类型的函数
@ -384,7 +384,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
} }
/** /**
* 和{@link FastStream#map(Function)}一样，只不过函数的返回值必须为long类型 * 和{@link EasyStream#map(Function)}一样，只不过函数的返回值必须为long类型
* 这是一个无状态中间操作 * 这是一个无状态中间操作
* *
* @param mapper 返回值为long类型的函数 * @param mapper 返回值为long类型的函数
@ -396,7 +396,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
} }
/** /**
* 和{@link FastStream#map(Function)}一样，只不过函数的返回值必须为double类型 * 和{@link EasyStream#map(Function)}一样，只不过函数的返回值必须为double类型
* 这是一个无状态中间操作 * 这是一个无状态中间操作
* *
* @param mapper 返回值为double类型的函数 * @param mapper 返回值为double类型的函数
@ -420,7 +420,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @param <R> 拆分后流的元素类型 * @param <R> 拆分后流的元素类型
* @return 返回叠加拆分操作后的流 * @return 返回叠加拆分操作后的流
*/ */
public <R> FastStream<R> flat(Function<? super T, ? extends Iterable<? extends R>> mapper) { public <R> EasyStream<R> flat(Function<? super T, ? extends Iterable<? extends R>> mapper) {
Objects.requireNonNull(mapper); Objects.requireNonNull(mapper);
return flatMap(w -> of(mapper.apply(w))); return flatMap(w -> of(mapper.apply(w)));
} }
@ -436,7 +436,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @see #flat(Function) * @see #flat(Function)
* @see #nonNull() * @see #nonNull()
*/ */
public <R> FastStream<R> flatNonNull(Function<? super T, ? extends Iterable<? extends R>> mapper) { public <R> EasyStream<R> flatNonNull(Function<? super T, ? extends Iterable<? extends R>> mapper) {
return nonNull().flat(mapper).nonNull(); return nonNull().flat(mapper).nonNull();
} }
@ -484,10 +484,10 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @param <R> 拆分后流的元素类型 * @param <R> 拆分后流的元素类型
* @return 返回叠加拆分操作后的流 * @return 返回叠加拆分操作后的流
*/ */
public <R> FastStream<R> mapMulti(BiConsumer<? super T, ? super FastStreamBuilder<R>> mapper) { public <R> EasyStream<R> mapMulti(BiConsumer<? super T, ? super FastStreamBuilder<R>> mapper) {
Objects.requireNonNull(mapper); Objects.requireNonNull(mapper);
return flatMap(e -> { return flatMap(e -> {
FastStreamBuilder<R> buffer = FastStream.builder(); FastStreamBuilder<R> buffer = EasyStream.builder();
mapper.accept(e, buffer); mapper.accept(e, buffer);
return buffer.build(); return buffer.build();
}); });
@ -500,8 +500,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @return 一个具有去重特征的流 * @return 一个具有去重特征的流
*/ */
@Override @Override
public FastStream<T> distinct() { public EasyStream<T> distinct() {
return new FastStream<>(stream.distinct()); return new EasyStream<>(stream.distinct());
} }
/** /**
@ -512,7 +512,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @param keyExtractor 去重依据 * @param keyExtractor 去重依据
* @return 一个具有去重特征的流 * @return 一个具有去重特征的流
*/ */
public <F> FastStream<T> distinct(Function<? super T, F> keyExtractor) { public <F> EasyStream<T> distinct(Function<? super T, F> keyExtractor) {
Objects.requireNonNull(keyExtractor); Objects.requireNonNull(keyExtractor);
if (isParallel()) { if (isParallel()) {
ConcurrentHashMap<F, Boolean> exists = MapUtil.newConcurrentHashMap(); ConcurrentHashMap<F, Boolean> exists = MapUtil.newConcurrentHashMap();
@ -548,8 +548,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @return 一个元素按自然顺序排序的流 * @return 一个元素按自然顺序排序的流
*/ */
@Override @Override
public FastStream<T> sorted() { public EasyStream<T> sorted() {
return new FastStream<>(stream.sorted()); return new EasyStream<>(stream.sorted());
} }
/** /**
@ -562,8 +562,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @return 一个元素按指定的Comparator排序的流 * @return 一个元素按指定的Comparator排序的流
*/ */
@Override @Override
public FastStream<T> sorted(Comparator<? super T> comparator) { public EasyStream<T> sorted(Comparator<? super T> comparator) {
return new FastStream<>(stream.sorted(comparator)); return new EasyStream<>(stream.sorted(comparator));
} }
/** /**
@ -584,8 +584,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* }</pre> * }</pre>
*/ */
@Override @Override
public FastStream<T> peek(Consumer<? super T> action) { public EasyStream<T> peek(Consumer<? super T> action) {
return new FastStream<>(stream.peek(action)); return new EasyStream<>(stream.peek(action));
} }
/** /**
@ -593,7 +593,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* *
* @return 返回叠加操作后的FastStream * @return 返回叠加操作后的FastStream
*/ */
public FastStream<T> log() { public EasyStream<T> log() {
return peek(Console::log); return peek(Console::log);
} }
@ -605,8 +605,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @return 截取后的流 * @return 截取后的流
*/ */
@Override @Override
public FastStream<T> limit(long maxSize) { public EasyStream<T> limit(long maxSize) {
return new FastStream<>(stream.limit(maxSize)); return new EasyStream<>(stream.limit(maxSize));
} }
/** /**
@ -617,8 +617,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @return 丢弃前面n个元素后的剩余元素组成的流 * @return 丢弃前面n个元素后的剩余元素组成的流
*/ */
@Override @Override
public FastStream<T> skip(long n) { public EasyStream<T> skip(long n) {
return new FastStream<>(stream.skip(n)); return new EasyStream<>(stream.skip(n));
} }
/** /**
@ -627,7 +627,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @return 串行流 * @return 串行流
*/ */
@Override @Override
public FastStream<T> sequential() { public EasyStream<T> sequential() {
//noinspection ResultOfMethodCallIgnored //noinspection ResultOfMethodCallIgnored
stream.sequential(); stream.sequential();
return this; return this;
@ -982,7 +982,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* *
* @return 反转元素顺序 * @return 反转元素顺序
*/ */
public FastStream<T> reverse() { public EasyStream<T> reverse() {
//noinspection unchecked //noinspection unchecked
final T[] array = (T[]) toArray(); final T[] array = (T[]) toArray();
ArrayUtil.reverse(array); ArrayUtil.reverse(array);
@ -1025,7 +1025,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @return 并行流 * @return 并行流
*/ */
@Override @Override
public FastStream<T> parallel() { public EasyStream<T> parallel() {
//noinspection ResultOfMethodCallIgnored //noinspection ResultOfMethodCallIgnored
stream.parallel(); stream.parallel();
return this; return this;
@ -1037,7 +1037,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @param parallel 是否并行 * @param parallel 是否并行
* @return 流 * @return 流
*/ */
public FastStream<T> parallel(boolean parallel) { public EasyStream<T> parallel(boolean parallel) {
return parallel ? parallel() : sequential(); return parallel ? parallel() : sequential();
} }
@ -1048,8 +1048,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @return 无序流 * @return 无序流
*/ */
@Override @Override
public FastStream<T> unordered() { public EasyStream<T> unordered() {
return new FastStream<>(stream.unordered()); return new EasyStream<>(stream.unordered());
} }
/** /**
@ -1059,7 +1059,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @return 流 * @return 流
*/ */
@Override @Override
public FastStream<T> onClose(Runnable closeHandler) { public EasyStream<T> onClose(Runnable closeHandler) {
//noinspection ResultOfMethodCallIgnored //noinspection ResultOfMethodCallIgnored
stream.onClose(closeHandler); stream.onClose(closeHandler);
return this; return this;
@ -1071,8 +1071,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @param obj 元素 * @param obj 元素
* @return 流 * @return 流
*/ */
public FastStream<T> push(T obj) { public EasyStream<T> push(T obj) {
return FastStream.concat(this.stream, of(obj)); return EasyStream.concat(this.stream, of(obj));
} }
/** /**
@ -1082,8 +1082,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @return 流 * @return 流
*/ */
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public FastStream<T> push(T... obj) { public EasyStream<T> push(T... obj) {
return FastStream.concat(this.stream, of(obj)); return EasyStream.concat(this.stream, of(obj));
} }
/** /**
@ -1092,8 +1092,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @param obj 元素 * @param obj 元素
* @return 流 * @return 流
*/ */
public FastStream<T> unshift(T obj) { public EasyStream<T> unshift(T obj) {
return FastStream.concat(of(obj), this.stream); return EasyStream.concat(of(obj), this.stream);
} }
/** /**
@ -1103,8 +1103,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @return 流 * @return 流
*/ */
@SafeVarargs @SafeVarargs
public final FastStream<T> unshift(T... obj) { public final EasyStream<T> unshift(T... obj) {
return FastStream.concat(of(obj), this.stream); return EasyStream.concat(of(obj), this.stream);
} }
/** /**
@ -1377,7 +1377,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @param <R> 合并后的结果对象类型 * @param <R> 合并后的结果对象类型
* @return 合并后的结果对象的流 * @return 合并后的结果对象的流
*/ */
public <U, R> FastStream<R> zip(Iterable<U> other, public <U, R> EasyStream<R> zip(Iterable<U> other,
BiFunction<? super T, ? super U, ? extends R> zipper) { BiFunction<? super T, ? super U, ? extends R> zipper) {
Objects.requireNonNull(zipper); Objects.requireNonNull(zipper);
final Spliterator<T> keys = spliterator(); final Spliterator<T> keys = spliterator();
@ -1406,7 +1406,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @return 操作后的流 * @return 操作后的流
*/ */
@SafeVarargs @SafeVarargs
public final FastStream<T> splice(int start, int deleteCount, T... items) { public final EasyStream<T> splice(int start, int deleteCount, T... items) {
return of(ListUtil.splice(toList(), start, deleteCount, items)) return of(ListUtil.splice(toList(), start, deleteCount, items))
.parallel(isParallel()) .parallel(isParallel())
.onClose(stream::close); .onClose(stream::close);
@ -1421,13 +1421,13 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @param batchSize 指定长度, 正整数 * @param batchSize 指定长度, 正整数
* @return 切好的流 * @return 切好的流
*/ */
public FastStream<FastStream<T>> split(final int batchSize) { public EasyStream<EasyStream<T>> split(final int batchSize) {
List<T> list = toList(); List<T> list = toList();
final int size = list.size(); final int size = list.size();
// 指定长度 大于等于 列表长度 // 指定长度 大于等于 列表长度
if (size <= batchSize) { if (size <= batchSize) {
// 返回第一层只有单个元素的双层流，形如：[[1,2,3,4,5]] // 返回第一层只有单个元素的双层流，形如：[[1,2,3,4,5]]
return FastStream.<FastStream<T>>of(of(list, isParallel())); return EasyStream.<EasyStream<T>>of(of(list, isParallel()));
} }
return iterate(0, i -> i < size, i -> i + batchSize) return iterate(0, i -> i < size, i -> i + batchSize)
.map(skip -> of(list.subList(skip, Math.min(size, skip + batchSize)), isParallel())) .map(skip -> of(list.subList(skip, Math.min(size, skip + batchSize)), isParallel()))
@ -1444,8 +1444,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @param batchSize 指定长度, 正整数 * @param batchSize 指定长度, 正整数
* @return 切好的流 * @return 切好的流
*/ */
public FastStream<List<T>> splitList(final int batchSize) { public EasyStream<List<T>> splitList(final int batchSize) {
return split(batchSize).map(FastStream::toList); return split(batchSize).map(EasyStream::toList);
} }
/** /**
@ -1467,7 +1467,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @param predicate 断言 * @param predicate 断言
* @return 与指定断言匹配的元素组成的流 * @return 与指定断言匹配的元素组成的流
*/ */
public FastStream<T> takeWhile(Predicate<? super T> predicate) { public EasyStream<T> takeWhile(Predicate<? super T> predicate) {
Objects.requireNonNull(predicate); Objects.requireNonNull(predicate);
return of(StreamUtil.takeWhile(stream, predicate)); return of(StreamUtil.takeWhile(stream, predicate));
} }
@ -1492,7 +1492,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
* @param predicate 断言 * @param predicate 断言
* @return 剩余元素组成的流 * @return 剩余元素组成的流
*/ */
public FastStream<T> dropWhile(Predicate<? super T> predicate) { public EasyStream<T> dropWhile(Predicate<? super T> predicate) {
Objects.requireNonNull(predicate); Objects.requireNonNull(predicate);
return of(StreamUtil.dropWhile(stream, predicate)); return of(StreamUtil.dropWhile(stream, predicate));
} }
@ -1515,7 +1515,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
return !isEmpty(); return !isEmpty();
} }
public interface FastStreamBuilder<T> extends Consumer<T>, cn.hutool.core.builder.Builder<FastStream<T>> { public interface FastStreamBuilder<T> extends Consumer<T>, cn.hutool.core.builder.Builder<EasyStream<T>> {
/** /**
* Adds an element to the stream being built. * Adds an element to the stream being built.

172
hutool-core/src/test/java/cn/hutool/core/stream/FastStreamTest.java → hutool-core/src/test/java/cn/hutool/core/stream/EasyStreamTest.java
View File

@ -15,57 +15,57 @@ import static java.util.Collections.singletonList;
/** /**
* @author VampireAchao * @author VampireAchao
*/ */
public class FastStreamTest { public class EasyStreamTest {
@Test @Test
public void testBuilder() { public void testBuilder() {
List<Integer> list = FastStream.<Integer>builder().add(1).add(2).add(3).build().toList(); List<Integer> list = EasyStream.<Integer>builder().add(1).add(2).add(3).build().toList();
Assert.assertEquals(Arrays.asList(1, 2, 3), list); Assert.assertEquals(Arrays.asList(1, 2, 3), list);
} }
@Test @Test
public void testGenerate() { public void testGenerate() {
List<Integer> list = FastStream.generate(() -> 0).limit(3).toList(); List<Integer> list = EasyStream.generate(() -> 0).limit(3).toList();
Assert.assertEquals(Arrays.asList(0, 0, 0), list); Assert.assertEquals(Arrays.asList(0, 0, 0), list);
} }
@Test @Test
public void testOf() { public void testOf() {
Assert.assertEquals(3, FastStream.of(Arrays.asList(1, 2, 3), true).count()); Assert.assertEquals(3, EasyStream.of(Arrays.asList(1, 2, 3), true).count());
Assert.assertEquals(3, FastStream.of(1, 2, 3).count()); Assert.assertEquals(3, EasyStream.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(Stream.builder().add(1).add(2).add(3).build()).count());
} }
@Test @Test
public void testSplit() { public void testSplit() {
List<Integer> list = FastStream.split("1,2,3", ",").map(Integer::valueOf).toList(); List<Integer> list = EasyStream.split("1,2,3", ",").map(Integer::valueOf).toList();
Assert.assertEquals(Arrays.asList(1, 2, 3), list); Assert.assertEquals(Arrays.asList(1, 2, 3), list);
} }
@Test @Test
public void testIterator() { public void testIterator() {
List<Integer> list = FastStream.iterate(0, i -> i < 3, i -> ++i).toList(); List<Integer> list = EasyStream.iterate(0, i -> i < 3, i -> ++i).toList();
Assert.assertEquals(Arrays.asList(0, 1, 2), list); Assert.assertEquals(Arrays.asList(0, 1, 2), list);
} }
@Test @Test
public void testToCollection() { public void testToCollection() {
List<Integer> list = Arrays.asList(1, 2, 3); List<Integer> list = Arrays.asList(1, 2, 3);
List<String> toCollection = FastStream.of(list).map(String::valueOf).toColl(LinkedList::new); List<String> toCollection = EasyStream.of(list).map(String::valueOf).toColl(LinkedList::new);
Assert.assertEquals(Arrays.asList("1", "2", "3"), toCollection); Assert.assertEquals(Arrays.asList("1", "2", "3"), toCollection);
} }
@Test @Test
public void testToList() { public void testToList() {
List<Integer> list = Arrays.asList(1, 2, 3); List<Integer> list = Arrays.asList(1, 2, 3);
List<String> toList = FastStream.of(list).map(String::valueOf).toList(); List<String> toList = EasyStream.of(list).map(String::valueOf).toList();
Assert.assertEquals(Arrays.asList("1", "2", "3"), toList); Assert.assertEquals(Arrays.asList("1", "2", "3"), toList);
} }
@Test @Test
public void testToSet() { public void testToSet() {
List<Integer> list = Arrays.asList(1, 2, 3); List<Integer> list = Arrays.asList(1, 2, 3);
Set<String> toSet = FastStream.of(list).map(String::valueOf).toSet(); Set<String> toSet = EasyStream.of(list).map(String::valueOf).toSet();
Assert.assertEquals(new HashSet<>(Arrays.asList("1", "2", "3")), toSet); Assert.assertEquals(new HashSet<>(Arrays.asList("1", "2", "3")), toSet);
} }
@ -79,26 +79,26 @@ public class FastStreamTest {
.put(3, "sweet") .put(3, "sweet")
.build(); .build();
Map<Integer, String> toZip = FastStream.of(orders).toZip(list); Map<Integer, String> toZip = EasyStream.of(orders).toZip(list);
Assert.assertEquals(map, toZip); Assert.assertEquals(map, toZip);
Map<Integer, String> toZipParallel = FastStream.of(orders).parallel().nonNull().toZip(list); Map<Integer, String> toZipParallel = EasyStream.of(orders).parallel().nonNull().toZip(list);
Assert.assertEquals(map, toZipParallel); Assert.assertEquals(map, toZipParallel);
} }
@Test @Test
public void testJoin() { public void testJoin() {
List<Integer> list = Arrays.asList(1, 2, 3); List<Integer> list = Arrays.asList(1, 2, 3);
String joining = FastStream.of(list).join(); String joining = EasyStream.of(list).join();
Assert.assertEquals("123", joining); Assert.assertEquals("123", joining);
Assert.assertEquals("1,2,3", FastStream.of(list).join(",")); Assert.assertEquals("1,2,3", EasyStream.of(list).join(","));
Assert.assertEquals("(1,2,3)", FastStream.of(list).join(",", "(", ")")); Assert.assertEquals("(1,2,3)", EasyStream.of(list).join(",", "(", ")"));
} }
@Test @Test
public void testToMap() { public void testToMap() {
List<Integer> list = Arrays.asList(1, 2, 3); List<Integer> list = Arrays.asList(1, 2, 3);
Map<String, Integer> identityMap = FastStream.of(list).toMap(String::valueOf); Map<String, Integer> identityMap = EasyStream.of(list).toMap(String::valueOf);
Assert.assertEquals(new HashMap<String, Integer>() { Assert.assertEquals(new HashMap<String, Integer>() {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
@ -113,7 +113,7 @@ public class FastStreamTest {
@Test @Test
public void testGroup() { public void testGroup() {
List<Integer> list = Arrays.asList(1, 2, 3); List<Integer> list = Arrays.asList(1, 2, 3);
Map<String, List<Integer>> group = FastStream.of(list).group(String::valueOf); Map<String, List<Integer>> group = EasyStream.of(list).group(String::valueOf);
Assert.assertEquals( Assert.assertEquals(
new HashMap<String, List<Integer>>() { new HashMap<String, List<Integer>>() {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
@ -129,16 +129,16 @@ public class FastStreamTest {
@Test @Test
public void testMapIdx() { public void testMapIdx() {
List<String> list = Arrays.asList("dromara", "hutool", "sweet"); List<String> list = Arrays.asList("dromara", "hutool", "sweet");
List<String> mapIndex = FastStream.of(list).mapIdx((e, i) -> i + 1 + "." + e).toList(); List<String> mapIndex = EasyStream.of(list).mapIdx((e, i) -> i + 1 + "." + e).toList();
Assert.assertEquals(Arrays.asList("1.dromara", "2.hutool", "3.sweet"), mapIndex); Assert.assertEquals(Arrays.asList("1.dromara", "2.hutool", "3.sweet"), mapIndex);
// 并行流时为-1 // 并行流时为-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 @Test
public void testMapMulti() { public void testMapMulti() {
List<Integer> list = Arrays.asList(1, 2, 3); List<Integer> list = Arrays.asList(1, 2, 3);
List<Integer> mapMulti = FastStream.of(list).<Integer>mapMulti((e, buffer) -> { List<Integer> mapMulti = EasyStream.of(list).<Integer>mapMulti((e, buffer) -> {
for (int i = 0; i < e; i++) { for (int i = 0; i < e; i++) {
buffer.accept(e); buffer.accept(e);
} }
@ -149,7 +149,7 @@ public class FastStreamTest {
@Test @Test
public void testMapNonNull() { public void testMapNonNull() {
List<Integer> list = Arrays.asList(1, 2, 3, null); List<Integer> list = Arrays.asList(1, 2, 3, null);
List<String> mapNonNull = FastStream.of(list).mapNonNull(String::valueOf).toList(); List<String> mapNonNull = EasyStream.of(list).mapNonNull(String::valueOf).toList();
Assert.assertEquals(Arrays.asList("1", "2", "3"), mapNonNull); Assert.assertEquals(Arrays.asList("1", "2", "3"), mapNonNull);
} }
@ -164,8 +164,8 @@ public class FastStreamTest {
List<Integer> collect2 = list.stream().parallel().distinct().collect(Collectors.toList()); List<Integer> collect2 = list.stream().parallel().distinct().collect(Collectors.toList());
// 使用FastStream去重 // 使用FastStream去重
List<Integer> distinctBy1 = FastStream.of(list).distinct().toList(); List<Integer> distinctBy1 = EasyStream.of(list).distinct().toList();
List<Integer> distinctBy2 = FastStream.of(list).parallel().distinct(String::valueOf).toList(); List<Integer> distinctBy2 = EasyStream.of(list).parallel().distinct(String::valueOf).toList();
Assert.assertEquals(collect1, distinctBy1); Assert.assertEquals(collect1, distinctBy1);
Assert.assertEquals(collect2, distinctBy2); Assert.assertEquals(collect2, distinctBy2);
@ -174,22 +174,22 @@ public class FastStreamTest {
@Test @Test
public void testForeachIdx() { public void testForeachIdx() {
List<String> list = Arrays.asList("dromara", "hutool", "sweet"); List<String> list = Arrays.asList("dromara", "hutool", "sweet");
FastStream.FastStreamBuilder<String> builder = FastStream.builder(); EasyStream.FastStreamBuilder<String> builder = EasyStream.builder();
FastStream.of(list).forEachIdx((e, i) -> builder.accept(i + 1 + "." + e)); EasyStream.of(list).forEachIdx((e, i) -> builder.accept(i + 1 + "." + e));
Assert.assertEquals(Arrays.asList("1.dromara", "2.hutool", "3.sweet"), builder.build().toList()); Assert.assertEquals(Arrays.asList("1.dromara", "2.hutool", "3.sweet"), builder.build().toList());
// 并行流时为-1 // 并行流时为-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 @Test
public void testForEachOrderedIdx() { public void testForEachOrderedIdx() {
List<String> list = Arrays.asList("dromara", "hutool", "sweet"); List<String> list = Arrays.asList("dromara", "hutool", "sweet");
FastStream.FastStreamBuilder<String> builder = FastStream.builder(); EasyStream.FastStreamBuilder<String> builder = EasyStream.builder();
FastStream.of(list).forEachOrderedIdx((e, i) -> builder.accept(i + 1 + "." + e)); EasyStream.of(list).forEachOrderedIdx((e, i) -> builder.accept(i + 1 + "." + e));
Assert.assertEquals(Arrays.asList("1.dromara", "2.hutool", "3.sweet"), builder.build().toList()); Assert.assertEquals(Arrays.asList("1.dromara", "2.hutool", "3.sweet"), builder.build().toList());
FastStream.FastStreamBuilder<String> streamBuilder = FastStream.builder(); EasyStream.FastStreamBuilder<String> streamBuilder = EasyStream.builder();
FastStream.of(list).parallel().forEachOrderedIdx((e, i) -> streamBuilder.accept(i + 1 + "." + e)); 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()); Assert.assertEquals(Arrays.asList("0.dromara", "0.hutool", "0.sweet"), streamBuilder.build().toList());
} }
@ -197,10 +197,10 @@ public class FastStreamTest {
@Test @Test
public void testFlatMapIdx() { public void testFlatMapIdx() {
List<String> list = Arrays.asList("dromara", "hutool", "sweet"); List<String> list = Arrays.asList("dromara", "hutool", "sweet");
List<String> mapIndex = FastStream.of(list).flatMapIdx((e, i) -> FastStream.of(i + 1 + "." + e)).toList(); List<String> mapIndex = EasyStream.of(list).flatMapIdx((e, i) -> EasyStream.of(i + 1 + "." + e)).toList();
Assert.assertEquals(Arrays.asList("1.dromara", "2.hutool", "3.sweet"), mapIndex); Assert.assertEquals(Arrays.asList("1.dromara", "2.hutool", "3.sweet"), mapIndex);
// 并行流时为-1 // 并行流时为-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 @Test
@ -208,172 +208,172 @@ public class FastStreamTest {
List<Integer> list = Arrays.asList(1, 2, 3); List<Integer> list = Arrays.asList(1, 2, 3);
// 一个元素 扩散为 多个元素(迭代器) // 一个元素 扩散为 多个元素(迭代器)
List<Integer> flat = FastStream.of(list).flat(e -> Arrays.asList(e, e * 10)).toList(); List<Integer> flat = EasyStream.of(list).flat(e -> Arrays.asList(e, e * 10)).toList();
Assert.assertEquals(ListUtil.of(1, 10, 2, 20, 3, 30), flat); Assert.assertEquals(ListUtil.of(1, 10, 2, 20, 3, 30), flat);
// 过滤迭代器为null的元素 // 过滤迭代器为null的元素
flat = FastStream.of(list).<Integer>flat(e -> null).toList(); flat = EasyStream.of(list).<Integer>flat(e -> null).toList();
Assert.assertEquals(Collections.emptyList(), flat); Assert.assertEquals(Collections.emptyList(), flat);
// 自动过滤null元素 // 自动过滤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); Assert.assertEquals(ListUtil.of(1, null, 2, null, 3, 3), flat);
// 不报npe测试 // 不报npe测试
Assert.assertTrue(FastStream.of(list).flat(e -> null).isEmpty()); Assert.assertTrue(EasyStream.of(list).flat(e -> null).isEmpty());
} }
@Test @Test
public void testFilter() { public void testFilter() {
List<Integer> list = Arrays.asList(1, 2, 3); List<Integer> list = Arrays.asList(1, 2, 3);
List<Integer> filterIndex = FastStream.of(list).filter(String::valueOf, "1").toList(); List<Integer> filterIndex = EasyStream.of(list).filter(String::valueOf, "1").toList();
Assert.assertEquals(Collections.singletonList(1), filterIndex); Assert.assertEquals(Collections.singletonList(1), filterIndex);
} }
@Test @Test
public void testFilterIdx() { public void testFilterIdx() {
List<String> list = Arrays.asList("dromara", "hutool", "sweet"); List<String> list = Arrays.asList("dromara", "hutool", "sweet");
List<String> filterIndex = FastStream.of(list).filterIdx((e, i) -> i < 2).toList(); List<String> filterIndex = EasyStream.of(list).filterIdx((e, i) -> i < 2).toList();
Assert.assertEquals(Arrays.asList("dromara", "hutool"), filterIndex); Assert.assertEquals(Arrays.asList("dromara", "hutool"), filterIndex);
// 并行流时为-1 // 并行流时为-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 @Test
public void testNonNull() { public void testNonNull() {
List<Integer> list = Arrays.asList(1, null, 2, 3); List<Integer> list = Arrays.asList(1, null, 2, 3);
List<Integer> nonNull = FastStream.of(list).nonNull().toList(); List<Integer> nonNull = EasyStream.of(list).nonNull().toList();
Assert.assertEquals(Arrays.asList(1, 2, 3), nonNull); Assert.assertEquals(Arrays.asList(1, 2, 3), nonNull);
} }
@Test @Test
public void testParallel() { public void testParallel() {
Assert.assertTrue(FastStream.of(1, 2, 3).parallel(true).isParallel()); Assert.assertTrue(EasyStream.of(1, 2, 3).parallel(true).isParallel());
Assert.assertFalse(FastStream.of(1, 2, 3).parallel(false).isParallel()); Assert.assertFalse(EasyStream.of(1, 2, 3).parallel(false).isParallel());
} }
@Test @Test
public void testPush() { public void testPush() {
List<Integer> list = Arrays.asList(1, 2); List<Integer> list = Arrays.asList(1, 2);
List<Integer> push = FastStream.of(list).push(3).toList(); List<Integer> push = EasyStream.of(list).push(3).toList();
Assert.assertEquals(Arrays.asList(1, 2, 3), push); 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 @Test
public void testUnshift() { public void testUnshift() {
List<Integer> list = Arrays.asList(2, 3); List<Integer> list = Arrays.asList(2, 3);
List<Integer> unshift = FastStream.of(list).unshift(1).toList(); List<Integer> unshift = EasyStream.of(list).unshift(1).toList();
Assert.assertEquals(Arrays.asList(1, 2, 3), unshift); 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 @Test
public void testAt() { public void testAt() {
List<Integer> list = Arrays.asList(1, 2, 3); List<Integer> list = Arrays.asList(1, 2, 3);
Assert.assertEquals(1, (Object) FastStream.of(list).at(0).orElse(null)); Assert.assertEquals(1, (Object) EasyStream.of(list).at(0).orElse(null));
Assert.assertEquals(2, (Object) FastStream.of(list).at(1).orElse(null)); Assert.assertEquals(2, (Object) EasyStream.of(list).at(1).orElse(null));
Assert.assertEquals(3, (Object) FastStream.of(list).at(2).orElse(null)); Assert.assertEquals(3, (Object) EasyStream.of(list).at(2).orElse(null));
Assert.assertEquals(1, (Object) FastStream.of(list).at(-3).orElse(null)); Assert.assertEquals(1, (Object) EasyStream.of(list).at(-3).orElse(null));
Assert.assertEquals(3, (Object) FastStream.of(list).at(-1).orElse(null)); Assert.assertEquals(3, (Object) EasyStream.of(list).at(-1).orElse(null));
Assert.assertNull(FastStream.of(list).at(-4).orElse(null)); Assert.assertNull(EasyStream.of(list).at(-4).orElse(null));
} }
@Test @Test
public void testSplice() { public void testSplice() {
List<Integer> list = Arrays.asList(1, 2, 3); List<Integer> 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, 2, 3), EasyStream.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, 3, 3), EasyStream.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, 4), EasyStream.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), EasyStream.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, 3), EasyStream.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), EasyStream.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, 3), EasyStream.of(list).splice(-2, 2, 2, 3).toList());
} }
@Test @Test
public void testFindFirst() { public void testFindFirst() {
List<Integer> list = Arrays.asList(1, 2, 3); List<Integer> 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); Assert.assertEquals(1, (Object) find);
} }
@Test @Test
public void testFindFirstIdx() { public void testFindFirstIdx() {
List<Integer> list = Arrays.asList(null, 2, 3); List<Integer> list = Arrays.asList(null, 2, 3);
Assert.assertEquals(1, FastStream.of(list).findFirstIdx(Objects::nonNull)); Assert.assertEquals(1, EasyStream.of(list).findFirstIdx(Objects::nonNull));
Assert.assertEquals(-1, (Object) FastStream.of(list).parallel().findFirstIdx(Objects::nonNull)); Assert.assertEquals(-1, (Object) EasyStream.of(list).parallel().findFirstIdx(Objects::nonNull));
} }
@Test @Test
public void testFindLast() { public void testFindLast() {
List<Integer> list = ListUtil.of(1, 2, 4, 5, 6, 7, 8, 9, 10, 3); 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) EasyStream.of(list).findLast().orElse(null));
Assert.assertEquals(3, (Object) FastStream.of(list).parallel().findLast().orElse(null)); Assert.assertEquals(3, (Object) EasyStream.of(list).parallel().findLast().orElse(null));
List<Integer> list2 = ListUtil.of(1, 2, 4, 5, 6, 7, 8, 9, 10, 3, 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.assertEquals(3, (Object) EasyStream.of(list2).parallel().findLast(Objects::nonNull).orElse(null));
Assert.assertNull(FastStream.of().parallel().findLast(Objects::nonNull).orElse(null)); Assert.assertNull(EasyStream.of().parallel().findLast(Objects::nonNull).orElse(null));
Assert.assertNull(FastStream.of((Object) null).parallel().findLast(Objects::nonNull).orElse(null)); Assert.assertNull(EasyStream.of((Object) null).parallel().findLast(Objects::nonNull).orElse(null));
} }
@Test @Test
public void testFindLastIdx() { public void testFindLastIdx() {
List<Integer> list = Arrays.asList(1, null, 3); List<Integer> list = Arrays.asList(1, null, 3);
Assert.assertEquals(2, (Object) FastStream.of(list).findLastIdx(Objects::nonNull)); Assert.assertEquals(2, (Object) EasyStream.of(list).findLastIdx(Objects::nonNull));
Assert.assertEquals(-1, (Object) FastStream.of(list).parallel().findLastIdx(Objects::nonNull)); Assert.assertEquals(-1, (Object) EasyStream.of(list).parallel().findLastIdx(Objects::nonNull));
} }
@Test @Test
public void testReverse() { public void testReverse() {
final List<Integer> list = ListUtil.of(Stream.iterate(1, i -> i + 1).limit(1000).collect(Collectors.toList())); 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.reverseNew(list), EasyStream.of(list).reverse().toList());
Assert.assertEquals(ListUtil.empty(), FastStream.of().reverse().toList()); Assert.assertEquals(ListUtil.empty(), EasyStream.of().reverse().toList());
Assert.assertEquals(ListUtil.of((Object) null), FastStream.of((Object) null).reverse().toList()); Assert.assertEquals(ListUtil.of((Object) null), EasyStream.of((Object) null).reverse().toList());
} }
@Test @Test
public void testZip() { public void testZip() {
List<Integer> orders = Arrays.asList(1, 2, 3); List<Integer> orders = Arrays.asList(1, 2, 3);
List<String> list = Arrays.asList("dromara", "hutool", "sweet"); List<String> list = Arrays.asList("dromara", "hutool", "sweet");
List<String> zip = FastStream.of(orders).zip(list, (e1, e2) -> e1 + "." + e2).toList(); List<String> zip = EasyStream.of(orders).zip(list, (e1, e2) -> e1 + "." + e2).toList();
Assert.assertEquals(Arrays.asList("1.dromara", "2.hutool", "3.sweet"), zip); 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); Assert.assertEquals(Arrays.asList("1.dromara", "2.hutool", "3.sweet"), zip);
} }
@Test @Test
public void testListSplit() { public void testListSplit() {
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5); List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
List<List<Integer>> lists = FastStream.of(list).split(2).map(FastStream::toList).toList(); List<List<Integer>> lists = EasyStream.of(list).split(2).map(EasyStream::toList).toList();
Assert.assertEquals(ListUtil.split(list, 2), lists); 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); Assert.assertEquals(singletonList(list), lists);
} }
@Test @Test
public void testSplitList() { public void testSplitList() {
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5); List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
List<List<Integer>> lists = FastStream.of(list).splitList(2).toList(); List<List<Integer>> lists = EasyStream.of(list).splitList(2).toList();
Assert.assertEquals(ListUtil.split(list, 2), lists); 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); Assert.assertEquals(singletonList(list), lists);
} }
@Test @Test
public void testTakeWhile() { public void testTakeWhile() {
// 1 到 10 // 1 到 10
final List<Integer> list = FastStream.iterate(1, i -> i <= 10, i -> i + 1).toList(); final List<Integer> list = EasyStream.iterate(1, i -> i <= 10, i -> i + 1).toList();
final List<String> res1 = FastStream.of(list) final List<String> res1 = EasyStream.of(list)
// 舍弃 5 // 舍弃 5
.takeWhile(e -> e < 5) .takeWhile(e -> e < 5)
// 过滤奇数 // 过滤奇数
@ -384,7 +384,7 @@ public class FastStreamTest {
.toList(); .toList();
Assert.assertEquals(Arrays.asList("4", "2"), res1); Assert.assertEquals(Arrays.asList("4", "2"), res1);
final List<Integer> res2 = FastStream.iterate(1, i -> i + 1) final List<Integer> res2 = EasyStream.iterate(1, i -> i + 1)
.parallel() .parallel()
.takeWhile(e -> e < 5) .takeWhile(e -> e < 5)
.map(String::valueOf) .map(String::valueOf)
@ -397,9 +397,9 @@ public class FastStreamTest {
@Test @Test
public void testDropWhile() { public void testDropWhile() {
// 1 到 10 // 1 到 10
final List<Integer> list = FastStream.iterate(1, i -> i <= 10, i -> i + 1).toList(); final List<Integer> list = EasyStream.iterate(1, i -> i <= 10, i -> i + 1).toList();
final List<String> res1 = FastStream.of(list) final List<String> res1 = EasyStream.of(list)
// 舍弃 5之前的数字 // 舍弃 5之前的数字
.dropWhile(e -> e < 5) .dropWhile(e -> e < 5)
// 过滤偶数 // 过滤偶数
@ -410,7 +410,7 @@ public class FastStreamTest {
.toList(); .toList();
Assert.assertEquals(Arrays.asList("9", "7", "5"), res1); Assert.assertEquals(Arrays.asList("9", "7", "5"), res1);
final List<Integer> res2 = FastStream.of(list) final List<Integer> res2 = EasyStream.of(list)
.parallel() .parallel()
.dropWhile(e -> e < 5) .dropWhile(e -> e < 5)
// 过滤偶数 // 过滤偶数
@ -424,7 +424,7 @@ public class FastStreamTest {
@Test @Test
public void testIsNotEmpty() { public void testIsNotEmpty() {
Assert.assertTrue(FastStream.of(1).isNotEmpty()); Assert.assertTrue(EasyStream.of(1).isNotEmpty());
} }
} }