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

1.删除多余文件;

Browse Source 
2.调整注释位置;
This commit is contained in:
emptypoint 2022-08-06 23:36:25 +08:00
parent 25196520d6
commit f17b0a4166
5 changed files with 4 additions and 318 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
hutool-core/src/main/java/cn/hutool/core/stream/FastStream.java
View File

@ -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;
@ -669,13 +668,15 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
/**
* 返回一个包含此流元素的指定的数组
* <p>
* 例如以下代码编译正常，但运行时会抛出 {@link ArrayStoreException}
* <pre>{@code String[] strings = Stream.<Integer>builder().add(1).build().toArray(String[]::new); }</pre>
* </p>
*
* @param generator 这里的IntFunction的参数是元素的个数，返回值为数组类型
* @param <A> 给定的数组类型
* @return 包含此流元素的指定的数组
* @throws ArrayStoreException 如果元素转换失败，例如不是该元素类型及其父类，则抛出该异常
* 例如以下代码编译正常，但运行时会抛出 {@link ArrayStoreException}
* <pre>{@code String[] strings = Stream.<Integer>builder().add(1).build().toArray(String[]::new); }</pre>
*/
@Override
public <A> A[] toArray(IntFunction<A[]> generator) {

72
hutool-core/src/main/java/cn/hutool/core/stream/support/DropWhileSpliterator.java
View File

@ -1,72 +0,0 @@
package cn.hutool.core.stream.support;
import java.util.Comparator;
import java.util.Spliterator;
import java.util.function.Consumer;
import java.util.function.Predicate;
/**
* dropWhile 的 Spliterator
* <p>借鉴自StreamEx</p>
*
* @author emptypoint
* @since 6.0.0
*/
class DropWhileSpliterator<T> implements Spliterator<T> {
static <T> DropWhileSpliterator<T> create(Spliterator<T> source, Predicate<? super T> predicate) {
return new DropWhileSpliterator<>(source, predicate);
}
private final Spliterator<T> source;
private final Predicate<? super T> predicate;
private boolean isFound = false;
private DropWhileSpliterator(Spliterator<T> source, Predicate<? super T> predicate) {
this.source = source;
this.predicate = predicate;
}
@Override
public boolean tryAdvance(Consumer<? super T> action) {
boolean hasNext = true;
// 如果 还没找到 并且 流中还有元素 继续找
while (!isFound && hasNext) {
hasNext = source.tryAdvance(e -> {
if (!predicate.test(e)) {
// 第一次不匹配
isFound = true;
action.accept(e);
}
});
}
// 对找到的元素进行后续处理
if (isFound) {
source.forEachRemaining(action);
}
// 该环节已经处理完成
return false;
}
@Override
public Spliterator<T> trySplit() {
return null;
}
@Override
public long estimateSize() {
return Long.MAX_VALUE;
}
@Override
public int characteristics() {
return source.characteristics() & ~Spliterator.SIZED;
}
@Override
public Comparator<? super T> getComparator() {
return source.getComparator();
}
}

76
hutool-core/src/main/java/cn/hutool/core/stream/support/IterateSpliterator.java
View File

@ -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);
}
}
}

99
hutool-core/src/main/java/cn/hutool/core/stream/support/StreamHelper.java
View File

@ -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
}

68
hutool-core/src/main/java/cn/hutool/core/stream/support/TakeWhileSpliterator.java
View File

@ -1,68 +0,0 @@
package cn.hutool.core.stream.support;
import java.util.Comparator;
import java.util.Spliterator;
import java.util.function.Consumer;
import java.util.function.Predicate;
/**
* takeWhile 的 Spliterator
* <p>借鉴自StreamEx</p>
*
* @author emptypoint
* @since 6.0.0
*/
class TakeWhileSpliterator<T> implements Spliterator<T> {
static <T> TakeWhileSpliterator<T> create(Spliterator<T> source, Predicate<? super T> predicate) {
return new TakeWhileSpliterator<>(source, predicate);
}
private final Spliterator<T> source;
private final Predicate<? super T> predicate;
private boolean isContinue = true;
TakeWhileSpliterator(Spliterator<T> source, Predicate<? super T> predicate) {
this.source = source;
this.predicate = predicate;
}
@Override
public boolean tryAdvance(Consumer<? super T> action) {
boolean hasNext = true;
// 如果 还可以继续 并且 流中还有元素 则继续遍历
while (isContinue && hasNext) {
hasNext = source.tryAdvance(e -> {
if (predicate.test(e)) {
action.accept(e);
} else {
// 终止遍历剩下的元素
isContinue = false;
}
});
}
// 该环节已经处理完成
return false;
}
@Override
public Spliterator<T> trySplit() {
return null;
}
@Override
public long estimateSize() {
return isContinue ? source.estimateSize() : 0;
}
@Override
public int characteristics() {
return source.characteristics() & ~(Spliterator.SIZED | Spliterator.SUBSIZED);
}
@Override
public Comparator<? super T> getComparator() {
return source.getComparator();
}
}