mirror of
https://gitee.com/chinabugotech/hutool.git
synced 2025-05-09 23:51:34 +08:00
:trollface: 审查、优化
This commit is contained in:
parent
3608f9dbe0
commit
db0e590fb1
@ -6,7 +6,6 @@ import cn.hutool.core.lang.Opt;
|
||||
import cn.hutool.core.lang.mutable.MutableInt;
|
||||
import cn.hutool.core.lang.mutable.MutableObj;
|
||||
import cn.hutool.core.map.MapUtil;
|
||||
import cn.hutool.core.stream.support.StreamHelper;
|
||||
import cn.hutool.core.text.StrUtil;
|
||||
import cn.hutool.core.util.ArrayUtil;
|
||||
|
||||
@ -158,7 +157,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
public static <T> FastStream<T> iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next) {
|
||||
Objects.requireNonNull(next);
|
||||
Objects.requireNonNull(hasNext);
|
||||
return new FastStream<>(StreamHelper.iterate(seed, hasNext, next));
|
||||
return new FastStream<>(StreamUtil.iterate(seed, hasNext, next));
|
||||
}
|
||||
|
||||
/**
|
||||
@ -674,8 +673,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
* @param <A> 给定的数组类型
|
||||
* @return 包含此流元素的指定的数组
|
||||
* @throws ArrayStoreException 如果元素转换失败,例如不是该元素类型及其父类,则抛出该异常
|
||||
* 例如以下代码编译正常,但运行时会抛出 {@link ArrayStoreException}
|
||||
* <pre>{@code String[] strings = Stream.<Integer>builder().add(1).build().toArray(String[]::new); }</pre>
|
||||
* 例如以下代码编译正常,但运行时会抛出 {@link ArrayStoreException}
|
||||
* <pre>{@code String[] strings = Stream.<Integer>builder().add(1).build().toArray(String[]::new); }</pre>
|
||||
*/
|
||||
@Override
|
||||
public <A> A[] toArray(IntFunction<A[]> generator) {
|
||||
@ -1423,8 +1422,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
* <p>与 jdk9 中的 takeWhile 方法不太一样, 这里的实现是个 顺序的、有状态的中间操作</p>
|
||||
* <pre>本环节中是顺序执行的, 但是后续操作可以支持并行流: {@code
|
||||
* FastStream.iterate(1, i -> i + 1)
|
||||
* .parallel()
|
||||
* // 顺序执行
|
||||
* .parallel()
|
||||
* // 顺序执行
|
||||
* .takeWhile(e -> e < 50)
|
||||
* // 并发
|
||||
* .map(e -> e + 1)
|
||||
@ -1439,7 +1438,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
*/
|
||||
public FastStream<T> takeWhile(Predicate<? super T> predicate) {
|
||||
Objects.requireNonNull(predicate);
|
||||
return of(StreamHelper.takeWhile(stream, predicate));
|
||||
return of(StreamUtil.takeWhile(stream, predicate));
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1459,8 +1458,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
* <p>与 jdk9 中的 dropWhile 方法不太一样, 这里的实现是个 顺序的、有状态的中间操作</p>
|
||||
* <pre>本环节中是顺序执行的, 但是后续操作可以支持并行流: {@code
|
||||
* FastStream.iterate(1, i <= 100, i -> i + 1)
|
||||
* .parallel()
|
||||
* // 顺序执行
|
||||
* .parallel()
|
||||
* // 顺序执行
|
||||
* .dropWhile(e -> e < 50)
|
||||
* // 并发
|
||||
* .map(e -> e + 1)
|
||||
@ -1475,7 +1474,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
*/
|
||||
public FastStream<T> dropWhile(Predicate<? super T> predicate) {
|
||||
Objects.requireNonNull(predicate);
|
||||
return of(StreamHelper.dropWhile(stream, predicate));
|
||||
return of(StreamUtil.dropWhile(stream, predicate));
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1490,6 +1489,24 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
return dropWhile(predicate);
|
||||
}
|
||||
|
||||
/**
|
||||
* 流是否为空
|
||||
*
|
||||
* @return 流是否为空
|
||||
*/
|
||||
public boolean isEmpty() {
|
||||
return !findAny().isPresent();
|
||||
}
|
||||
|
||||
/**
|
||||
* 流是否不为空
|
||||
*
|
||||
* @return 流是否不为空
|
||||
*/
|
||||
public boolean isNotEmpty() {
|
||||
return !isEmpty();
|
||||
}
|
||||
|
||||
public interface FastStreamBuilder<T> extends Consumer<T>, cn.hutool.core.builder.Builder<FastStream<T>> {
|
||||
|
||||
/**
|
||||
|
@ -3,6 +3,9 @@ package cn.hutool.core.stream;
|
||||
import cn.hutool.core.collection.CollUtil;
|
||||
import cn.hutool.core.io.IORuntimeException;
|
||||
import cn.hutool.core.lang.Assert;
|
||||
import cn.hutool.core.stream.spliterators.DropWhileSpliterator;
|
||||
import cn.hutool.core.stream.spliterators.IterateSpliterator;
|
||||
import cn.hutool.core.stream.spliterators.TakeWhileSpliterator;
|
||||
import cn.hutool.core.util.CharsetUtil;
|
||||
|
||||
import java.io.File;
|
||||
@ -10,16 +13,20 @@ import java.io.IOException;
|
||||
import java.nio.charset.Charset;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.util.Spliterator;
|
||||
import java.util.Spliterators;
|
||||
import java.util.function.Function;
|
||||
import java.util.function.Predicate;
|
||||
import java.util.function.UnaryOperator;
|
||||
import java.util.stream.Stream;
|
||||
import java.util.stream.StreamSupport;
|
||||
|
||||
import static java.util.Objects.requireNonNull;
|
||||
|
||||
/**
|
||||
* {@link Stream} 工具类
|
||||
*
|
||||
* @author looly
|
||||
* @author looly emptypoint VampireAchao
|
||||
* @since 5.6.7
|
||||
*/
|
||||
public class StreamUtil {
|
||||
@ -141,4 +148,84 @@ public class StreamUtil {
|
||||
final Function<T, ? extends CharSequence> toStringFunc) {
|
||||
return stream.collect(CollectorUtil.joining(delimiter, toStringFunc));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* 返回无限有序流
|
||||
* 该流由 初始值 然后判断条件 以及执行 迭代函数 进行迭代获取到元素
|
||||
*
|
||||
* @param <T> 元素类型
|
||||
* @param seed 初始值
|
||||
* @param hasNext 条件值
|
||||
* @param next 用上一个元素作为参数执行并返回一个新的元素
|
||||
* @return 无限有序流
|
||||
*/
|
||||
public static <T> Stream<T> iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next) {
|
||||
requireNonNull(next);
|
||||
requireNonNull(hasNext);
|
||||
return StreamSupport.stream(IterateSpliterator.create(seed, hasNext, next), false);
|
||||
}
|
||||
|
||||
/**
|
||||
* 保留 与指定断言 匹配时的元素, 在第一次不匹配时终止, 抛弃当前(第一个不匹配元素)及后续所有元素
|
||||
* <p>与 jdk9 中的 takeWhile 方法不太一样, 这里的实现是个 顺序的、有状态的中间操作</p>
|
||||
* <p>本环节中是顺序执行的, 但是后续操作可以支持并行流</p>
|
||||
* <p>但是不建议在并行流中使用, 除非你确定 takeWhile 之后的操作能在并行流中受益很多</p>
|
||||
*
|
||||
* @param source 源流
|
||||
* @param <T> 元素类型
|
||||
* @param predicate 断言
|
||||
* @return 与指定断言匹配的元素组成的流
|
||||
*/
|
||||
public static <T> Stream<T> takeWhile(Stream<T> source, Predicate<? super T> predicate) {
|
||||
requireNonNull(source);
|
||||
requireNonNull(predicate);
|
||||
return createStatefulNewStream(source, TakeWhileSpliterator.create(source.spliterator(), predicate));
|
||||
}
|
||||
|
||||
/**
|
||||
* 删除 与指定断言 匹配的元素, 在第一次不匹配时终止, 返回当前(第一个不匹配元素)及剩余元素组成的新流
|
||||
* <p>与 jdk9 中的 dropWhile 方法不太一样, 这里的实现是个 顺序的、有状态的中间操作</p>
|
||||
* <p>本环节中是顺序执行的, 但是后续操作可以支持并行流</p>
|
||||
* <p>但是不建议在并行流中使用, 除非你确定 dropWhile 之后的操作能在并行流中受益很多</p>
|
||||
*
|
||||
* @param source 源流
|
||||
* @param <T> 元素类型
|
||||
* @param predicate 断言
|
||||
* @return 剩余元素组成的流
|
||||
*/
|
||||
public static <T> Stream<T> dropWhile(Stream<T> source, Predicate<? super T> predicate) {
|
||||
requireNonNull(source);
|
||||
requireNonNull(predicate);
|
||||
return createStatefulNewStream(source, DropWhileSpliterator.create(source.spliterator(), predicate));
|
||||
}
|
||||
|
||||
// region 私有方法
|
||||
/* ================================================== 私有方法 =================================================== */
|
||||
|
||||
/**
|
||||
* 根据 源流 和 新的Spliterator 生成新的流
|
||||
* <p>这是一个 顺序的、有状态的流</p>
|
||||
* <p>在新流的第一个节点是顺序执行的, 但是后续操作可以支持并行流</p>
|
||||
*
|
||||
* @param source 源流
|
||||
* @param newSpliterator 新流的Spliterator
|
||||
* @param <T> 旧流的元素类型
|
||||
* @param <R> 新流的元素类型
|
||||
* @return 新流
|
||||
*/
|
||||
private static <T, R> Stream<R> createStatefulNewStream(Stream<T> source, Spliterator<R> newSpliterator) {
|
||||
// 创建新流
|
||||
Stream<R> newStream = StreamSupport.stream(newSpliterator, source.isParallel());
|
||||
// 如果旧流是并行流, 新流主动调用一个有状态的操作, 虽然没有意义, 但是可以让后续的无状态节点正常并发
|
||||
if (source.isParallel()) {
|
||||
newStream = newStream.limit(Long.MAX_VALUE);
|
||||
}
|
||||
// 由于新流不与旧流的节点关联, 所以需要主动设置旧流的close方法, 哪怕几乎不可能有人在旧流上设置onClose操作
|
||||
return newStream.onClose(source::close);
|
||||
}
|
||||
|
||||
/* ============================================================================================================== */
|
||||
// endregion
|
||||
|
||||
}
|
||||
|
@ -1,4 +1,4 @@
|
||||
package cn.hutool.core.stream.support;
|
||||
package cn.hutool.core.stream.spliterators;
|
||||
|
||||
import java.util.Comparator;
|
||||
import java.util.Spliterator;
|
||||
@ -12,9 +12,9 @@ import java.util.function.Predicate;
|
||||
* @author emptypoint
|
||||
* @since 6.0.0
|
||||
*/
|
||||
class DropWhileSpliterator<T> implements Spliterator<T> {
|
||||
public class DropWhileSpliterator<T> implements Spliterator<T> {
|
||||
|
||||
static <T> DropWhileSpliterator<T> create(Spliterator<T> source, Predicate<? super T> predicate) {
|
||||
public static <T> DropWhileSpliterator<T> create(Spliterator<T> source, Predicate<? super T> predicate) {
|
||||
return new DropWhileSpliterator<>(source, predicate);
|
||||
}
|
||||
|
@ -0,0 +1,76 @@
|
||||
package cn.hutool.core.stream.spliterators;
|
||||
|
||||
import java.util.Objects;
|
||||
import java.util.Spliterator;
|
||||
import java.util.Spliterators;
|
||||
import java.util.function.Consumer;
|
||||
import java.util.function.Predicate;
|
||||
import java.util.function.UnaryOperator;
|
||||
|
||||
/**
|
||||
* 无限有序流 的Spliterator
|
||||
*
|
||||
* @author VampireAchao
|
||||
* @since 6.0.0
|
||||
*/
|
||||
public class IterateSpliterator<T> extends Spliterators.AbstractSpliterator<T> {
|
||||
private final T seed;
|
||||
private final Predicate<? super T> hasNext;
|
||||
private final UnaryOperator<T> next;
|
||||
private T prev;
|
||||
private boolean started;
|
||||
private boolean finished;
|
||||
|
||||
/**
|
||||
* Creates a spliterator reporting the given estimated size and
|
||||
* additionalCharacteristics.
|
||||
*/
|
||||
IterateSpliterator(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next) {
|
||||
super(Long.MAX_VALUE, Spliterator.ORDERED | Spliterator.IMMUTABLE);
|
||||
this.seed = seed;
|
||||
this.hasNext = hasNext;
|
||||
this.next = next;
|
||||
}
|
||||
|
||||
public static <T> IterateSpliterator<T> create(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next) {
|
||||
return new IterateSpliterator<>(seed, hasNext, next);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean tryAdvance(Consumer<? super T> action) {
|
||||
Objects.requireNonNull(action);
|
||||
if (finished) {
|
||||
return false;
|
||||
}
|
||||
T t;
|
||||
if (started) {
|
||||
t = next.apply(prev);
|
||||
} else {
|
||||
t = seed;
|
||||
started = true;
|
||||
}
|
||||
if (!hasNext.test(t)) {
|
||||
prev = null;
|
||||
finished = true;
|
||||
return false;
|
||||
}
|
||||
prev = t;
|
||||
action.accept(prev);
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void forEachRemaining(Consumer<? super T> action) {
|
||||
Objects.requireNonNull(action);
|
||||
if (finished) {
|
||||
return;
|
||||
}
|
||||
finished = true;
|
||||
T t = started ? next.apply(prev) : seed;
|
||||
prev = null;
|
||||
while (hasNext.test(t)) {
|
||||
action.accept(t);
|
||||
t = next.apply(t);
|
||||
}
|
||||
}
|
||||
}
|
@ -1,4 +1,4 @@
|
||||
package cn.hutool.core.stream.support;
|
||||
package cn.hutool.core.stream.spliterators;
|
||||
|
||||
import java.util.Comparator;
|
||||
import java.util.Spliterator;
|
||||
@ -12,9 +12,9 @@ import java.util.function.Predicate;
|
||||
* @author emptypoint
|
||||
* @since 6.0.0
|
||||
*/
|
||||
class TakeWhileSpliterator<T> implements Spliterator<T> {
|
||||
public class TakeWhileSpliterator<T> implements Spliterator<T> {
|
||||
|
||||
static <T> TakeWhileSpliterator<T> create(Spliterator<T> source, Predicate<? super T> predicate) {
|
||||
public static <T> TakeWhileSpliterator<T> create(Spliterator<T> source, Predicate<? super T> predicate) {
|
||||
return new TakeWhileSpliterator<>(source, predicate);
|
||||
}
|
||||
|
@ -1,76 +0,0 @@
|
||||
package cn.hutool.core.stream.support;
|
||||
|
||||
import java.util.Objects;
|
||||
import java.util.Spliterator;
|
||||
import java.util.Spliterators;
|
||||
import java.util.function.Consumer;
|
||||
import java.util.function.Predicate;
|
||||
import java.util.function.UnaryOperator;
|
||||
|
||||
/**
|
||||
* 无限有序流 的Spliterator
|
||||
*
|
||||
* @author VampireAchao
|
||||
* @since 6.0.0
|
||||
*/
|
||||
class IterateSpliterator<T> extends Spliterators.AbstractSpliterator<T> {
|
||||
public static <T> IterateSpliterator<T> create(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next) {
|
||||
return new IterateSpliterator<>(seed, hasNext, next);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a spliterator reporting the given estimated size and
|
||||
* additionalCharacteristics.
|
||||
*/
|
||||
IterateSpliterator(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next) {
|
||||
super(Long.MAX_VALUE, Spliterator.ORDERED | Spliterator.IMMUTABLE);
|
||||
this.seed = seed;
|
||||
this.hasNext = hasNext;
|
||||
this.next = next;
|
||||
}
|
||||
|
||||
private final T seed;
|
||||
private final Predicate<? super T> hasNext;
|
||||
private final UnaryOperator<T> next;
|
||||
private T prev;
|
||||
private boolean started;
|
||||
private boolean finished;
|
||||
|
||||
@Override
|
||||
public boolean tryAdvance(Consumer<? super T> action) {
|
||||
Objects.requireNonNull(action);
|
||||
if (finished) {
|
||||
return false;
|
||||
}
|
||||
T t;
|
||||
if (started) {
|
||||
t = next.apply(prev);
|
||||
} else {
|
||||
t = seed;
|
||||
started = true;
|
||||
}
|
||||
if (!hasNext.test(t)) {
|
||||
prev = null;
|
||||
finished = true;
|
||||
return false;
|
||||
}
|
||||
prev = t;
|
||||
action.accept(prev);
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void forEachRemaining(Consumer<? super T> action) {
|
||||
Objects.requireNonNull(action);
|
||||
if (finished) {
|
||||
return;
|
||||
}
|
||||
finished = true;
|
||||
T t = started ? next.apply(prev) : seed;
|
||||
prev = null;
|
||||
while (hasNext.test(t)) {
|
||||
action.accept(t);
|
||||
t = next.apply(t);
|
||||
}
|
||||
}
|
||||
}
|
@ -1,99 +0,0 @@
|
||||
package cn.hutool.core.stream.support;
|
||||
|
||||
import java.util.Spliterator;
|
||||
import java.util.function.Predicate;
|
||||
import java.util.function.UnaryOperator;
|
||||
import java.util.stream.Stream;
|
||||
import java.util.stream.StreamSupport;
|
||||
|
||||
import static java.util.Objects.requireNonNull;
|
||||
|
||||
/**
|
||||
* FastStream 辅助工具类
|
||||
*
|
||||
* @author emptypoint
|
||||
* @since 6.0.0
|
||||
*/
|
||||
public final class StreamHelper {
|
||||
private StreamHelper() {
|
||||
}
|
||||
|
||||
/**
|
||||
* 返回无限有序流
|
||||
* 该流由 初始值 然后判断条件 以及执行 迭代函数 进行迭代获取到元素
|
||||
*
|
||||
* @param <T> 元素类型
|
||||
* @param seed 初始值
|
||||
* @param hasNext 条件值
|
||||
* @param next 用上一个元素作为参数执行并返回一个新的元素
|
||||
* @return 无限有序流
|
||||
*/
|
||||
public static <T> Stream<T> iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next) {
|
||||
requireNonNull(next);
|
||||
requireNonNull(hasNext);
|
||||
return StreamSupport.stream(IterateSpliterator.create(seed, hasNext, next), false);
|
||||
}
|
||||
|
||||
/**
|
||||
* 保留 与指定断言 匹配时的元素, 在第一次不匹配时终止, 抛弃当前(第一个不匹配元素)及后续所有元素
|
||||
* <p>与 jdk9 中的 takeWhile 方法不太一样, 这里的实现是个 顺序的、有状态的中间操作</p>
|
||||
* <p>本环节中是顺序执行的, 但是后续操作可以支持并行流</p>
|
||||
* <p>但是不建议在并行流中使用, 除非你确定 takeWhile 之后的操作能在并行流中受益很多</p>
|
||||
*
|
||||
* @param source 源流
|
||||
* @param <T> 元素类型
|
||||
* @param predicate 断言
|
||||
* @return 与指定断言匹配的元素组成的流
|
||||
*/
|
||||
public static <T> Stream<T> takeWhile(Stream<T> source, Predicate<? super T> predicate) {
|
||||
requireNonNull(source);
|
||||
requireNonNull(predicate);
|
||||
return createStatefulNewStream(source, TakeWhileSpliterator.create(source.spliterator(), predicate));
|
||||
}
|
||||
|
||||
/**
|
||||
* 删除 与指定断言 匹配的元素, 在第一次不匹配时终止, 返回当前(第一个不匹配元素)及剩余元素组成的新流
|
||||
* <p>与 jdk9 中的 dropWhile 方法不太一样, 这里的实现是个 顺序的、有状态的中间操作</p>
|
||||
* <p>本环节中是顺序执行的, 但是后续操作可以支持并行流</p>
|
||||
* <p>但是不建议在并行流中使用, 除非你确定 dropWhile 之后的操作能在并行流中受益很多</p>
|
||||
*
|
||||
* @param source 源流
|
||||
* @param <T> 元素类型
|
||||
* @param predicate 断言
|
||||
* @return 剩余元素组成的流
|
||||
*/
|
||||
public static <T> Stream<T> dropWhile(Stream<T> source, Predicate<? super T> predicate) {
|
||||
requireNonNull(source);
|
||||
requireNonNull(predicate);
|
||||
return createStatefulNewStream(source, DropWhileSpliterator.create(source.spliterator(), predicate));
|
||||
}
|
||||
|
||||
// region 私有方法
|
||||
/* ================================================== 私有方法 =================================================== */
|
||||
|
||||
/**
|
||||
* 根据 源流 和 新的Spliterator 生成新的流
|
||||
* <p>这是一个 顺序的、有状态的流</p>
|
||||
* <p>在新流的第一个节点是顺序执行的, 但是后续操作可以支持并行流</p>
|
||||
*
|
||||
* @param source 源流
|
||||
* @param newSpliterator 新流的Spliterator
|
||||
* @param <T> 旧流的元素类型
|
||||
* @param <R> 新流的元素类型
|
||||
* @return 新流
|
||||
*/
|
||||
private static <T, R> Stream<R> createStatefulNewStream(Stream<T> source, Spliterator<R> newSpliterator) {
|
||||
// 创建新流
|
||||
Stream<R> newStream = StreamSupport.stream(newSpliterator, source.isParallel());
|
||||
// 如果旧流是并行流, 新流主动调用一个有状态的操作, 虽然没有意义, 但是可以让后续的无状态节点正常并发
|
||||
if (source.isParallel()) {
|
||||
newStream = newStream.limit(Long.MAX_VALUE);
|
||||
}
|
||||
// 由于新流不与旧流的节点关联, 所以需要主动设置旧流的close方法, 哪怕几乎不可能有人在旧流上设置onClose操作
|
||||
return newStream.onClose(source::close);
|
||||
}
|
||||
|
||||
/* ============================================================================================================== */
|
||||
// endregion
|
||||
|
||||
}
|
@ -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考虑了字符串为空串的情况
|
||||
|
@ -193,6 +193,8 @@ public class FastStreamTest {
|
||||
|
||||
flatMapIter = FastStream.of(list).flatMapIter(e -> Arrays.asList(e, e * 10)).toList();
|
||||
Assert.assertEquals(ListUtil.of(1, 10, 2, 20, 3, 30), flatMapIter);
|
||||
// 不报npe测试
|
||||
Assert.assertTrue(FastStream.of(list).flatMapIter(e -> null).isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -310,6 +312,9 @@ public class FastStreamTest {
|
||||
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
|
||||
@ -388,4 +393,9 @@ public class FastStreamTest {
|
||||
Assert.assertEquals(Arrays.asList(5, 7, 9), res2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsNotEmpty() {
|
||||
Assert.assertTrue(FastStream.of(1).isNotEmpty());
|
||||
}
|
||||
|
||||
}
|
||||
|
Loading…
x
Reference in New Issue
Block a user