mirror of
https://gitee.com/chinabugotech/hutool.git
synced 2025-04-19 03:01:48 +08:00
fixed fc8923b from https://gitee.com/VampireAchao/hutool/pulls/742
优化FastStream: 1.新增takeWhile、dropWhile方法; 2.优化部分写法, 希望进一步提高效率; 3.删除多余的代码, 移动部分代码到其他类中;
This commit is contained in:
Zjp
阿超
parent
aa403cbe98
commit
3608f9dbe0
@ -13,6 +13,7 @@ import cn.hutool.core.util.ObjUtil;
|
||||
import cn.hutool.core.util.PageUtil;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collection;
|
||||
import java.util.Collections;
|
||||
import java.util.Comparator;
|
||||
@ -692,4 +693,51 @@ public class ListUtil {
|
||||
}
|
||||
return list;
|
||||
}
|
||||
|
||||
/**
|
||||
* 类似js的<a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/splice">splice</a>函数
|
||||
*
|
||||
* @param start 起始下标, 可以为负数, -1代表最后一个元素
|
||||
* @param deleteCount 删除个数，必须是正整数
|
||||
* @param items 放入值
|
||||
* @return 操作后的流
|
||||
* @since 6.0.0
|
||||
*/
|
||||
@SafeVarargs
|
||||
public static <T> List<T> splice(List<T> list, int start, int deleteCount, T... items) {
|
||||
if (CollUtil.isEmpty(list)) {
|
||||
return zero();
|
||||
}
|
||||
final int size = list.size();
|
||||
// 从后往前查找
|
||||
if (start < 0) {
|
||||
start += size;
|
||||
} else if (start >= size) {
|
||||
// 直接在尾部追加，不删除
|
||||
start = size;
|
||||
deleteCount = 0;
|
||||
}
|
||||
// 起始位置 加上 删除的数量 超过 数据长度，需要重新计算需要删除的数量
|
||||
if (start + deleteCount > size) {
|
||||
deleteCount = size - start;
|
||||
}
|
||||
|
||||
// 新列表的长度
|
||||
final int newSize = size - deleteCount + items.length;
|
||||
List<T> resList = list;
|
||||
// 新列表的长度 大于 旧列表，创建新列表
|
||||
if (newSize > size) {
|
||||
resList = new ArrayList<>(newSize);
|
||||
resList.addAll(list);
|
||||
}
|
||||
// 需要删除的部分
|
||||
if (deleteCount > 0) {
|
||||
resList.subList(start, start + deleteCount).clear();
|
||||
}
|
||||
// 新增的部分
|
||||
if (ArrayUtil.isNotEmpty(items)) {
|
||||
resList.addAll(start, Arrays.asList(items));
|
||||
}
|
||||
return resList;
|
||||
}
|
||||
}
|
||||
|
||||
@ -127,6 +127,19 @@ public class Opt<T> {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 根据 {@link Optional} 构造 {@code Opt}
|
||||
*
|
||||
* @param optional optional
|
||||
* @param <T> 包裹的元素类型
|
||||
* @return 一个包裹里元素可能为空的 {@code Opt}
|
||||
* @since 6.0.0
|
||||
*/
|
||||
@SuppressWarnings("OptionalUsedAsFieldOrParameterType")
|
||||
public static <T> Opt<T> of(Optional<T> optional) {
|
||||
return ofNullable(optional).flattedMap(Function.identity());
|
||||
}
|
||||
|
||||
/**
|
||||
* 包裹里实际的元素
|
||||
*/
|
||||
|
||||
@ -81,6 +81,47 @@ public class MutableInt extends Number implements Comparable<MutableInt>, Mutabl
|
||||
return this;
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
/**
|
||||
* 先加1, 再获取值
|
||||
*
|
||||
* @return +1后的值
|
||||
* @since 6.0.0
|
||||
*/
|
||||
public int incrementAndGet() {
|
||||
return ++value;
|
||||
}
|
||||
|
||||
/**
|
||||
* 先获取原来的值, 再加1
|
||||
*
|
||||
* @return 原始值
|
||||
* @since 6.0.0
|
||||
*/
|
||||
public int getAndIncrement() {
|
||||
return value++;
|
||||
}
|
||||
|
||||
/**
|
||||
* 先减1, 再获取值
|
||||
*
|
||||
* @return -1后的值
|
||||
* @since 6.0.0
|
||||
*/
|
||||
public int decrementAndGet() {
|
||||
return --value;
|
||||
}
|
||||
|
||||
/**
|
||||
* 先获取原来的值, 再减1
|
||||
*
|
||||
* @return 原始值
|
||||
* @since 6.0.0
|
||||
*/
|
||||
public int getAndDecrement() {
|
||||
return value--;
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
/**
|
||||
* 增加值
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
package cn.hutool.core.lang.mutable;
|
||||
|
||||
import java.io.Serializable;
|
||||
import java.util.function.Consumer;
|
||||
|
||||
/**
|
||||
* 可变{@code Object}
|
||||
@ -8,7 +9,7 @@ import java.io.Serializable;
|
||||
* @param <T> 可变的类型
|
||||
* @since 3.0.1
|
||||
*/
|
||||
public class MutableObj<T> implements Mutable<T>, Serializable {
|
||||
public class MutableObj<T> implements Mutable<T>, Serializable, Consumer<T> {
|
||||
private static final long serialVersionUID = 1L;
|
||||
|
||||
/**
|
||||
@ -50,6 +51,17 @@ public class MutableObj<T> implements Mutable<T>, Serializable {
|
||||
this.value = value;
|
||||
}
|
||||
|
||||
/**
|
||||
* 消费元素
|
||||
*
|
||||
* @param t t
|
||||
* @since 6.0.0
|
||||
*/
|
||||
@Override
|
||||
public void accept(T t) {
|
||||
this.value = t;
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
@Override
|
||||
public boolean equals(final Object obj) {
|
||||
|
||||
@ -1,12 +1,12 @@
|
||||
package cn.hutool.core.stream;
|
||||
|
||||
import cn.hutool.core.collection.CollUtil;
|
||||
import cn.hutool.core.collection.ListUtil;
|
||||
import cn.hutool.core.lang.Console;
|
||||
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;
|
||||
|
||||
@ -61,6 +61,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
this.stream = stream;
|
||||
}
|
||||
|
||||
// region Static method
|
||||
// --------------------------------------------------------------- Static method start
|
||||
|
||||
/**
|
||||
@ -157,51 +158,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);
|
||||
Spliterator<T> spliterator = new Spliterators.AbstractSpliterator<T>(Long.MAX_VALUE,
|
||||
Spliterator.ORDERED | Spliterator.IMMUTABLE) {
|
||||
T prev;
|
||||
boolean started;
|
||||
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);
|
||||
}
|
||||
}
|
||||
};
|
||||
return new FastStream<>(StreamSupport.stream(spliterator, false));
|
||||
return new FastStream<>(StreamHelper.iterate(seed, hasNext, next));
|
||||
}
|
||||
|
||||
/**
|
||||
@ -279,6 +236,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------- Static method end
|
||||
// endregion
|
||||
|
||||
/**
|
||||
* 过滤元素，返回与指定断言匹配的元素组成的流
|
||||
@ -303,10 +261,9 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
*/
|
||||
public <R> FastStream<T> filter(Function<? super T, ? extends R> mapper, R value) {
|
||||
Objects.requireNonNull(mapper);
|
||||
return filter(e -> Objects.equals(Opt.ofNullable(e).map(mapper).get(), value));
|
||||
return filter(e -> Objects.equals(mapper.apply(e), value));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* 过滤元素，返回与指定断言匹配的元素组成的流，断言带下标，并行流时下标永远为-1
|
||||
* 这是一个无状态中间操作
|
||||
@ -320,7 +277,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
return filter(e -> predicate.test(e, NOT_FOUND_INDEX));
|
||||
} else {
|
||||
MutableInt index = new MutableInt(NOT_FOUND_INDEX);
|
||||
return filter(e -> predicate.test(e, index.increment().get()));
|
||||
return filter(e -> predicate.test(e, index.incrementAndGet()));
|
||||
}
|
||||
}
|
||||
|
||||
@ -360,7 +317,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
return map(e -> mapper.apply(e, NOT_FOUND_INDEX));
|
||||
} else {
|
||||
MutableInt index = new MutableInt(NOT_FOUND_INDEX);
|
||||
return map(e -> mapper.apply(e, index.increment().get()));
|
||||
return map(e -> mapper.apply(e, index.incrementAndGet()));
|
||||
}
|
||||
}
|
||||
|
||||
@ -395,7 +352,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
return flatMap(e -> mapper.apply(e, NOT_FOUND_INDEX));
|
||||
} else {
|
||||
MutableInt index = new MutableInt(NOT_FOUND_INDEX);
|
||||
return flatMap(e -> mapper.apply(e, index.increment().get()));
|
||||
return flatMap(e -> mapper.apply(e, index.incrementAndGet()));
|
||||
}
|
||||
}
|
||||
|
||||
@ -449,7 +406,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
*/
|
||||
public <R> FastStream<R> flatMapIter(Function<? super T, ? extends Iterable<? extends R>> mapper) {
|
||||
Objects.requireNonNull(mapper);
|
||||
return flatMap(w -> Opt.of(w).map(mapper).map(FastStream::of).orElseGet(FastStream::empty));
|
||||
return flatMap(w -> of(mapper.apply(w)));
|
||||
}
|
||||
|
||||
/**
|
||||
@ -668,7 +625,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
stream.forEach(e -> action.accept(e, NOT_FOUND_INDEX));
|
||||
} else {
|
||||
MutableInt index = new MutableInt(NOT_FOUND_INDEX);
|
||||
stream.forEach(e -> action.accept(e, index.increment().get()));
|
||||
stream.forEach(e -> action.accept(e, index.incrementAndGet()));
|
||||
}
|
||||
}
|
||||
|
||||
@ -695,7 +652,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
stream.forEachOrdered(e -> action.accept(e, NOT_FOUND_INDEX));
|
||||
} else {
|
||||
MutableInt index = new MutableInt(NOT_FOUND_INDEX);
|
||||
stream.forEachOrdered(e -> action.accept(e, index.increment().get()));
|
||||
stream.forEachOrdered(e -> action.accept(e, index.incrementAndGet()));
|
||||
}
|
||||
}
|
||||
|
||||
@ -916,8 +873,8 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
* @param predicate 断言
|
||||
* @return 与给定断言匹配的第一个元素
|
||||
*/
|
||||
public T findFirst(Predicate<? super T> predicate) {
|
||||
return stream.filter(predicate).findFirst().orElse(null);
|
||||
public Optional<T> findFirst(Predicate<? super T> predicate) {
|
||||
return stream.filter(predicate).findFirst();
|
||||
}
|
||||
|
||||
/**
|
||||
@ -926,7 +883,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
* @param predicate 断言
|
||||
* @return 与给定断言匹配的第一个元素的下标，如果不存在则返回-1
|
||||
*/
|
||||
public Integer findFirstIdx(Predicate<? super T> predicate) {
|
||||
public int findFirstIdx(Predicate<? super T> predicate) {
|
||||
Objects.requireNonNull(predicate);
|
||||
if (isParallel()) {
|
||||
return NOT_FOUND_INDEX;
|
||||
@ -947,13 +904,9 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
* @return 最后一个元素
|
||||
*/
|
||||
public Optional<T> findLast() {
|
||||
if (isParallel()) {
|
||||
return Optional.of(toList()).filter(CollUtil::isNotEmpty).map(l -> l.get(l.size() - 1));
|
||||
} else {
|
||||
MutableObj<T> last = new MutableObj<>(null);
|
||||
forEach(last::set);
|
||||
return Optional.ofNullable(last.get());
|
||||
}
|
||||
MutableObj<T> last = new MutableObj<>(null);
|
||||
spliterator().forEachRemaining(last);
|
||||
return Optional.ofNullable(last.get());
|
||||
}
|
||||
|
||||
/**
|
||||
@ -962,21 +915,15 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
* @param predicate 断言
|
||||
* @return 与给定断言匹配的最后一个元素
|
||||
*/
|
||||
public T findLast(Predicate<? super T> predicate) {
|
||||
public Optional<T> findLast(Predicate<? super T> predicate) {
|
||||
Objects.requireNonNull(predicate);
|
||||
if (isParallel()) {
|
||||
List<T> list = toList();
|
||||
final int index = ListUtil.lastIndexOf(list, predicate);
|
||||
return index == NOT_FOUND_INDEX ? null : list.get(index);
|
||||
} else {
|
||||
MutableObj<T> last = new MutableObj<>(null);
|
||||
forEach(e -> {
|
||||
if (predicate.test(e)) {
|
||||
last.set(e);
|
||||
}
|
||||
});
|
||||
return last.get();
|
||||
}
|
||||
MutableObj<T> last = new MutableObj<>(null);
|
||||
spliterator().forEachRemaining(e -> {
|
||||
if (predicate.test(e)) {
|
||||
last.set(e);
|
||||
}
|
||||
});
|
||||
return Optional.ofNullable(last.get());
|
||||
}
|
||||
|
||||
/**
|
||||
@ -985,7 +932,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
* @param predicate 断言
|
||||
* @return 与给定断言匹配的最后一个元素的下标，如果不存在则返回-1
|
||||
*/
|
||||
public Integer findLastIdx(Predicate<? super T> predicate) {
|
||||
public int findLastIdx(Predicate<? super T> predicate) {
|
||||
Objects.requireNonNull(predicate);
|
||||
if (isParallel()) {
|
||||
return NOT_FOUND_INDEX;
|
||||
@ -1006,9 +953,10 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
* @return 反转元素顺序
|
||||
*/
|
||||
public FastStream<T> reverse() {
|
||||
List<T> list = toList();
|
||||
Collections.reverse(list);
|
||||
return of(list, isParallel());
|
||||
//noinspection unchecked
|
||||
final T[] array = (T[]) toArray();
|
||||
ArrayUtil.reverse(array);
|
||||
return of(array).parallel(isParallel()).onClose(stream::close);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1065,6 +1013,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
|
||||
/**
|
||||
* 返回一个无序流(无手动排序)
|
||||
* <p>标记一个流是不在意元素顺序的, 在并行流的某些情况下可以提高性能</p>
|
||||
*
|
||||
* @return 无序流
|
||||
*/
|
||||
@ -1134,11 +1083,11 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
* @param idx 下标
|
||||
* @return 指定下标的元素
|
||||
*/
|
||||
public T at(Integer idx) {
|
||||
if (Objects.isNull(idx)) {
|
||||
return null;
|
||||
}
|
||||
return CollUtil.get(toList(), idx);
|
||||
public Optional<T> at(Integer idx) {
|
||||
return Opt.ofNullable(idx).map(i -> {
|
||||
//noinspection unchecked
|
||||
return (T) ArrayUtil.get(toArray(), i);
|
||||
}).toOptional();
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1225,28 +1174,29 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
}
|
||||
|
||||
/**
|
||||
* 与给定的可迭代对象转换成map，key为现有元素，value为给定可迭代对象迭代的元素<br>
|
||||
* 至少包含全部的key，如果对应位置上的value不存在，则为null
|
||||
* 与给定的可迭代对象转换成Map，key为现有元素，value为给定可迭代对象迭代的元素<br>
|
||||
* Map的大小与两个集合中较小的数量一致, 即, 只合并下标位置相同的部分
|
||||
*
|
||||
* @param other 可迭代对象
|
||||
* @param <R> 可迭代对象迭代的元素类型
|
||||
* @return map，key为现有元素，value为给定可迭代对象迭代的元素;<br>
|
||||
* 至少包含全部的key，如果对应位置上的value不存在，则为null;<br>
|
||||
* 如果key重复, 则保留最后一个关联的value;<br>
|
||||
* @return map，key为现有元素，value为给定可迭代对象迭代的元素
|
||||
*/
|
||||
public <R> Map<T, R> toZip(Iterable<R> other) {
|
||||
// value对象迭代器
|
||||
final Iterator<R> iterator = Opt.ofNullable(other).map(Iterable::iterator).orElseGet(Collections::emptyIterator);
|
||||
if (isParallel()) {
|
||||
List<T> keyList = toList();
|
||||
final Map<T, R> map = MapUtil.newHashMap(keyList.size());
|
||||
for (T key : keyList) {
|
||||
map.put(key, iterator.hasNext() ? iterator.next() : null);
|
||||
}
|
||||
return map;
|
||||
} else {
|
||||
return toMap(Function.identity(), e -> iterator.hasNext() ? iterator.next() : null);
|
||||
final Spliterator<T> keys = spliterator();
|
||||
final Spliterator<R> values = Opt.ofNullable(other).map(Iterable::spliterator).orElseGet(Spliterators::emptySpliterator);
|
||||
// 获取两个Spliterator的中较小的数量
|
||||
// 如果Spliterator经过流操作, getExactSizeIfKnown()可能会返回-1, 所以默认大小为 MapUtil.DEFAULT_INITIAL_CAPACITY
|
||||
final int sizeIfKnown = (int) Math.max(Math.min(keys.getExactSizeIfKnown(), values.getExactSizeIfKnown()), MapUtil.DEFAULT_INITIAL_CAPACITY);
|
||||
final Map<T, R> map = MapUtil.newHashMap(sizeIfKnown);
|
||||
// 保存第一个Spliterator的值
|
||||
MutableObj<T> key = new MutableObj<>();
|
||||
// 保存第二个Spliterator的值
|
||||
MutableObj<R> value = new MutableObj<>();
|
||||
// 当两个Spliterator中都还有剩余元素时
|
||||
while (keys.tryAdvance(key) && values.tryAdvance(value)) {
|
||||
map.put(key.get(), value.get());
|
||||
}
|
||||
return map;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1389,8 +1339,7 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
|
||||
/**
|
||||
* 将 现有元素 与 给定迭代器中对应位置的元素 使用 zipper 转换为新的元素，并返回新元素组成的流<br>
|
||||
* 新流的数量等于旧流元素的数量<br>
|
||||
* 使用 zipper 转换时, 如果对应位置上已经没有other元素，则other元素为null<br>
|
||||
* 新流的数量为两个集合中较小的数量, 即, 只合并下标位置相同的部分<br>
|
||||
*
|
||||
* @param other 给定的迭代器
|
||||
* @param zipper 两个元素的合并器
|
||||
@ -1401,15 +1350,21 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
public <U, R> FastStream<R> zip(Iterable<U> other,
|
||||
BiFunction<? super T, ? super U, ? extends R> zipper) {
|
||||
Objects.requireNonNull(zipper);
|
||||
// 给定对象迭代器
|
||||
final Iterator<U> iterator = Opt.ofNullable(other).map(Iterable::iterator).orElseGet(Collections::emptyIterator);
|
||||
Stream<T> resStream = this.stream;
|
||||
if (isParallel()) {
|
||||
resStream = toList().stream();
|
||||
final Spliterator<T> keys = spliterator();
|
||||
final Spliterator<U> values = Opt.ofNullable(other).map(Iterable::spliterator).orElseGet(Spliterators::emptySpliterator);
|
||||
// 获取两个Spliterator的中较小的数量
|
||||
// 如果Spliterator经过流操作, getExactSizeIfKnown()可能会返回-1, 所以默认大小为 ArrayList.DEFAULT_CAPACITY
|
||||
final int sizeIfKnown = (int) Math.max(Math.min(keys.getExactSizeIfKnown(), values.getExactSizeIfKnown()), 10);
|
||||
final List<R> list = new ArrayList<>(sizeIfKnown);
|
||||
// 保存第一个Spliterator的值
|
||||
MutableObj<T> key = new MutableObj<>();
|
||||
// 保存第二个Spliterator的值
|
||||
MutableObj<U> value = new MutableObj<>();
|
||||
// 当两个Spliterator中都还有剩余元素时
|
||||
while (keys.tryAdvance(key) && values.tryAdvance(value)) {
|
||||
list.add(zipper.apply(key.get(), value.get()));
|
||||
}
|
||||
final FastStream<R> newStream = of(resStream.map(e -> zipper.apply(e, iterator.hasNext() ? iterator.next() : null)));
|
||||
newStream.parallel(isParallel());
|
||||
return newStream;
|
||||
return of(list).parallel(isParallel()).onClose(stream::close);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1420,40 +1375,11 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
* @param items 放入值
|
||||
* @return 操作后的流
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
public FastStream<T> splice(int start, int deleteCount, T... items) {
|
||||
List<T> list = toList();
|
||||
final int size = list.size();
|
||||
// 从后往前查找
|
||||
if (start < 0) {
|
||||
start += size;
|
||||
} else if (start >= size) {
|
||||
// 直接在尾部追加，不删除
|
||||
start = size;
|
||||
deleteCount = 0;
|
||||
}
|
||||
// 起始位置 加上 删除的数量 超过 数据长度，需要重新计算需要删除的数量
|
||||
if (start + deleteCount > size) {
|
||||
deleteCount = size - start;
|
||||
}
|
||||
|
||||
// 新列表的长度
|
||||
final int newSize = size - deleteCount + items.length;
|
||||
List<T> resList = list;
|
||||
// 新列表的长度 大于 旧列表，创建新列表
|
||||
if (newSize > size) {
|
||||
resList = new ArrayList<>(newSize);
|
||||
resList.addAll(list);
|
||||
}
|
||||
// 需要删除的部分
|
||||
if (deleteCount > 0) {
|
||||
resList.subList(start, start + deleteCount).clear();
|
||||
}
|
||||
// 新增的部分
|
||||
if (items.length > 0) {
|
||||
resList.addAll(start, Arrays.asList(items));
|
||||
}
|
||||
return FastStream.of(resList);
|
||||
@SafeVarargs
|
||||
public final FastStream<T> splice(int start, int deleteCount, T... items) {
|
||||
return of(ListUtil.splice(toList(), start, deleteCount, items))
|
||||
.parallel(isParallel())
|
||||
.onClose(stream::close);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1473,9 +1399,10 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
// 返回第一层只有单个元素的双层流，形如：[[1,2,3,4,5]]
|
||||
return FastStream.<FastStream<T>>of(of(list, isParallel()));
|
||||
}
|
||||
return FastStream.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()))
|
||||
.parallel(isParallel());
|
||||
.parallel(isParallel())
|
||||
.onClose(stream::close);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1491,6 +1418,78 @@ public class FastStream<T> implements Stream<T>, Iterable<T> {
|
||||
return split(batchSize).map(FastStream::toList);
|
||||
}
|
||||
|
||||
/**
|
||||
* 保留 与指定断言 匹配时的元素, 在第一次不匹配时终止, 抛弃当前(第一个不匹配元素)及后续所有元素
|
||||
* <p>与 jdk9 中的 takeWhile 方法不太一样, 这里的实现是个 顺序的、有状态的中间操作</p>
|
||||
* <pre>本环节中是顺序执行的, 但是后续操作可以支持并行流: {@code
|
||||
* FastStream.iterate(1, i -> i + 1)
|
||||
* .parallel()
|
||||
* // 顺序执行
|
||||
* .takeWhile(e -> e < 50)
|
||||
* // 并发
|
||||
* .map(e -> e + 1)
|
||||
* // 并发
|
||||
* .map(String::valueOf)
|
||||
* .toList();
|
||||
* }</pre>
|
||||
* <p>但是不建议在并行流中使用, 除非你确定 takeWhile 之后的操作能在并行流中受益很多</p>
|
||||
*
|
||||
* @param predicate 断言
|
||||
* @return 与指定断言匹配的元素组成的流
|
||||
*/
|
||||
public FastStream<T> takeWhile(Predicate<? super T> predicate) {
|
||||
Objects.requireNonNull(predicate);
|
||||
return of(StreamHelper.takeWhile(stream, predicate));
|
||||
}
|
||||
|
||||
/**
|
||||
* 保留 与指定断言 匹配的元素, 在第一次不匹配时终止, 抛弃当前(第一个不匹配元素)及后续所有元素
|
||||
* <p>takeWhile 的别名方法</p>
|
||||
*
|
||||
* @param predicate 断言
|
||||
* @return 与指定断言匹配的元素组成的流
|
||||
* @see #takeWhile(Predicate)
|
||||
*/
|
||||
public FastStream<T> limit(Predicate<? super T> predicate) {
|
||||
return takeWhile(predicate);
|
||||
}
|
||||
|
||||
/**
|
||||
* 删除 与指定断言 匹配的元素, 在第一次不匹配时终止, 返回当前(第一个不匹配元素)及剩余元素组成的新流
|
||||
* <p>与 jdk9 中的 dropWhile 方法不太一样, 这里的实现是个 顺序的、有状态的中间操作</p>
|
||||
* <pre>本环节中是顺序执行的, 但是后续操作可以支持并行流: {@code
|
||||
* FastStream.iterate(1, i <= 100, i -> i + 1)
|
||||
* .parallel()
|
||||
* // 顺序执行
|
||||
* .dropWhile(e -> e < 50)
|
||||
* // 并发
|
||||
* .map(e -> e + 1)
|
||||
* // 并发
|
||||
* .map(String::valueOf)
|
||||
* .toList();
|
||||
* }</pre>
|
||||
* <p>但是不建议在并行流中使用, 除非你确定 dropWhile 之后的操作能在并行流中受益很多</p>
|
||||
*
|
||||
* @param predicate 断言
|
||||
* @return 剩余元素组成的流
|
||||
*/
|
||||
public FastStream<T> dropWhile(Predicate<? super T> predicate) {
|
||||
Objects.requireNonNull(predicate);
|
||||
return of(StreamHelper.dropWhile(stream, predicate));
|
||||
}
|
||||
|
||||
/**
|
||||
* 跳过 与断言匹配的元素, 在第一次不匹配时终止, 返回当前(第一个不匹配元素)及剩余元素组成的新流
|
||||
* <p>dropWhile 的别名方法</p>
|
||||
*
|
||||
* @param predicate 断言
|
||||
* @return 剩余元素组成的流
|
||||
* @see #dropWhile(Predicate)
|
||||
*/
|
||||
public FastStream<T> skip(Predicate<? super T> predicate) {
|
||||
return dropWhile(predicate);
|
||||
}
|
||||
|
||||
public interface FastStreamBuilder<T> extends Consumer<T>, cn.hutool.core.builder.Builder<FastStream<T>> {
|
||||
|
||||
/**
|
||||
|
||||
@ -0,0 +1,72 @@
|
||||
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();
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,76 @@
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,99 @@
|
||||
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
|
||||
|
||||
}
|
||||
@ -0,0 +1,68 @@
|
||||
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();
|
||||
}
|
||||
}
|
||||
|
||||
@ -76,7 +76,7 @@ public class FastStreamTest {
|
||||
Map<Integer, String> toZip = FastStream.of(orders).toZip(list);
|
||||
Assert.assertEquals(map, toZip);
|
||||
|
||||
Map<Integer, String> toZipParallel = FastStream.of(orders).parallel().toZip(list);
|
||||
Map<Integer, String> toZipParallel = FastStream.of(orders).parallel().nonNull().toZip(list);
|
||||
Assert.assertEquals(map, toZipParallel);
|
||||
}
|
||||
|
||||
@ -241,10 +241,12 @@ public class FastStreamTest {
|
||||
@Test
|
||||
public void testAt() {
|
||||
List<Integer> list = Arrays.asList(1, 2, 3);
|
||||
Assert.assertEquals(1, (Object) FastStream.of(list).at(0));
|
||||
Assert.assertEquals(1, (Object) FastStream.of(list).at(-3));
|
||||
Assert.assertEquals(3, (Object) FastStream.of(list).at(-1));
|
||||
Assert.assertNull(FastStream.of(list).at(-4));
|
||||
Assert.assertEquals(1, (Object) FastStream.of(list).at(0).orElse(null));
|
||||
Assert.assertEquals(2, (Object) FastStream.of(list).at(1).orElse(null));
|
||||
Assert.assertEquals(3, (Object) FastStream.of(list).at(2).orElse(null));
|
||||
Assert.assertEquals(1, (Object) FastStream.of(list).at(-3).orElse(null));
|
||||
Assert.assertEquals(3, (Object) FastStream.of(list).at(-1).orElse(null));
|
||||
Assert.assertNull(FastStream.of(list).at(-4).orElse(null));
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -262,34 +264,46 @@ public class FastStreamTest {
|
||||
@Test
|
||||
public void testFindFirst() {
|
||||
List<Integer> list = Arrays.asList(1, 2, 3);
|
||||
Integer find = FastStream.of(list).findFirst(Objects::nonNull);
|
||||
Integer find = FastStream.of(list).findFirst(Objects::nonNull).orElse(null);
|
||||
Assert.assertEquals(1, (Object) find);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindFirstIdx() {
|
||||
List<Integer> list = Arrays.asList(null, 2, 3);
|
||||
Integer idx = FastStream.of(list).findFirstIdx(Objects::nonNull);
|
||||
Assert.assertEquals(1, (Object) idx);
|
||||
Assert.assertEquals(1, FastStream.of(list).findFirstIdx(Objects::nonNull));
|
||||
Assert.assertEquals(-1, (Object) FastStream.of(list).parallel().findFirstIdx(Objects::nonNull));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindLast() {
|
||||
List<Integer> list = ListUtil.of(1, null, 3);
|
||||
Integer find = FastStream.of(list).parallel().findLast(Objects::nonNull);
|
||||
Assert.assertEquals(3, (Object) find);
|
||||
List<Integer> list = ListUtil.of(1, 2, 4, 5, 6, 7, 8, 9, 10, 3);
|
||||
Assert.assertEquals(3, (Object) FastStream.of(list).findLast().orElse(null));
|
||||
Assert.assertEquals(3, (Object) FastStream.of(list).parallel().findLast().orElse(null));
|
||||
|
||||
List<Integer> list2 = ListUtil.of(1, 2, 4, 5, 6, 7, 8, 9, 10, 3, null);
|
||||
Assert.assertEquals(3, (Object) FastStream.of(list2).parallel().findLast(Objects::nonNull).orElse(null));
|
||||
|
||||
Assert.assertNull(FastStream.of().parallel().findLast(Objects::nonNull).orElse(null));
|
||||
Assert.assertNull(FastStream.of((Object) null).parallel().findLast(Objects::nonNull).orElse(null));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindLastIdx() {
|
||||
List<Integer> list = Arrays.asList(1, null, 3);
|
||||
Integer idx = FastStream.of(list).findLastIdx(Objects::nonNull);
|
||||
Assert.assertEquals(2, (Object) idx);
|
||||
Assert.assertEquals(2, (Object) FastStream.of(list).findLastIdx(Objects::nonNull));
|
||||
Assert.assertEquals(-1, (Object) FastStream.of(list).parallel().findLastIdx(Objects::nonNull));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testReverse() {
|
||||
final List<Integer> list = ListUtil.of(Stream.iterate(1, i -> i + 1).limit(1000).collect(Collectors.toList()));
|
||||
|
||||
Assert.assertEquals(ListUtil.reverseNew(list), FastStream.of(list).reverse().toList());
|
||||
Assert.assertEquals(ListUtil.empty(), FastStream.of().reverse().toList());
|
||||
Assert.assertEquals(ListUtil.of((Object) null), FastStream.of((Object) null).reverse().toList());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testZip() {
|
||||
List<Integer> orders = Arrays.asList(1, 2, 3);
|
||||
@ -319,4 +333,59 @@ public class FastStreamTest {
|
||||
lists = FastStream.of(list).splitList(list.size()).toList();
|
||||
Assert.assertEquals(singletonList(list), lists);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testTakeWhile() {
|
||||
// 1 到 10
|
||||
final List<Integer> list = FastStream.iterate(1, i -> i <= 10, i -> i + 1).toList();
|
||||
|
||||
final List<String> res1 = FastStream.of(list)
|
||||
// 舍弃 5
|
||||
.takeWhile(e -> e < 5)
|
||||
// 过滤奇数
|
||||
.filter(e -> (e & 1) == 0)
|
||||
// 反序
|
||||
.sorted(Comparator.reverseOrder())
|
||||
.map(String::valueOf)
|
||||
.toList();
|
||||
Assert.assertEquals(Arrays.asList("4", "2"), res1);
|
||||
|
||||
final List<Integer> res2 = FastStream.iterate(1, i -> i + 1)
|
||||
.parallel()
|
||||
.takeWhile(e -> e < 5)
|
||||
.map(String::valueOf)
|
||||
.map(Integer::valueOf)
|
||||
.sorted(Comparator.naturalOrder())
|
||||
.toList();
|
||||
Assert.assertEquals(Arrays.asList(1, 2, 3, 4), res2);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testDropWhile() {
|
||||
// 1 到 10
|
||||
final List<Integer> list = FastStream.iterate(1, i -> i <= 10, i -> i + 1).toList();
|
||||
|
||||
final List<String> res1 = FastStream.of(list)
|
||||
// 舍弃 5之前的数字
|
||||
.dropWhile(e -> e < 5)
|
||||
// 过滤偶数
|
||||
.filter(e -> (e & 1) == 1)
|
||||
// 反序
|
||||
.sorted(Comparator.reverseOrder())
|
||||
.map(String::valueOf)
|
||||
.toList();
|
||||
Assert.assertEquals(Arrays.asList("9", "7", "5"), res1);
|
||||
|
||||
final List<Integer> res2 = FastStream.of(list)
|
||||
.parallel()
|
||||
.dropWhile(e -> e < 5)
|
||||
// 过滤偶数
|
||||
.filter(e -> (e & 1) == 1)
|
||||
.map(String::valueOf)
|
||||
.map(Integer::valueOf)
|
||||
.sorted(Comparator.naturalOrder())
|
||||
.toList();
|
||||
Assert.assertEquals(Arrays.asList(5, 7, 9), res2);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user