EasyStream相关：完善了注释，为部分工厂方法添加空值处理，并补充一个新方法

hutool-core/src/main/java/cn/hutool/core/stream/EasyStream.java

@@ -9,13 +9,42 @@ import cn.hutool.core.lang.mutable.MutableObj;
 import cn.hutool.core.map.MapUtil;
 import cn.hutool.core.text.StrUtil;
 import cn.hutool.core.util.ArrayUtil;
-import cn.hutool.core.util.ObjUtil;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.Spliterator;
+import java.util.Spliterators;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.function.*;
+import java.util.function.BiConsumer;
-import java.util.stream.*;
+import java.util.function.BiFunction;
+import java.util.function.BiPredicate;
+import java.util.function.BinaryOperator;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.IntFunction;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+import java.util.function.ToDoubleFunction;
+import java.util.function.ToIntFunction;
+import java.util.function.ToLongFunction;
+import java.util.function.UnaryOperator;
+import java.util.stream.Collector;
+import java.util.stream.Collectors;
+import java.util.stream.DoubleStream;
+import java.util.stream.IntStream;
+import java.util.stream.LongStream;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
 
 /**
  * <p>{@link Stream}的扩展实现，基于原生Stream进行了封装和增强。<br />
@@ -60,8 +89,13 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 
 	protected final Stream<T> stream;
 
-	EasyStream(Stream<T> stream) {
+	/**
-		this.stream = stream;
+	 * 构造
+	 *
+	 * @param stream {@link Stream}
+	 */
+	EasyStream(final Stream<T> stream) {
+		this.stream = null == stream ? Stream.empty() : stream;
 	}
 
 	// region Static method
@@ -79,7 +113,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 			private final Builder<T> streamBuilder = Stream.builder();
 
 			@Override
-			public void accept(T t) {
+			public void accept(final T t) {
 				streamBuilder.accept(t);
 			}
 
@@ -107,7 +141,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param <T> 元素类型
 	 * @return 包含单个元素的串行流
 	 */
-	public static <T> EasyStream<T> of(T t) {
+	public static <T> EasyStream<T> of(final T t) {
 		return new EasyStream<>(Stream.of(t));
 	}
 
@@ -121,7 +155,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 */
 	@SafeVarargs
 	@SuppressWarnings("varargs")
-	public static <T> EasyStream<T> of(T... values) {
+	public static <T> EasyStream<T> of(final T... values) {
 		return ArrayUtil.isEmpty(values) ? EasyStream.empty() : new EasyStream<>(Stream.of(values));
 	}
 
@@ -132,7 +166,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param <T>      元素类型
 	 * @return 流
 	 */
-	public static <T> EasyStream<T> of(Iterable<T> iterable) {
+	public static <T> EasyStream<T> of(final Iterable<T> iterable) {
 		return of(iterable, false);
 	}
 
@@ -144,8 +178,12 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param <T>      元素类型
 	 * @return 流
 	 */
-	public static <T> EasyStream<T> of(Iterable<T> iterable, boolean parallel) {
+	public static <T> EasyStream<T> of(final Iterable<T> iterable, final boolean parallel) {
-		return Opt.ofNullable(iterable).map(Iterable::spliterator).map(spliterator -> StreamSupport.stream(spliterator, parallel)).map(EasyStream::new).orElseGet(EasyStream::empty);
+		return Opt.ofNullable(iterable)
+				.map(Iterable::spliterator)
+				.map(spliterator -> StreamSupport.stream(spliterator, parallel))
+				.map(EasyStream::new)
+				.orElseGet(EasyStream::empty);
 	}
 
 	/**
@@ -155,8 +193,8 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param <T>    元素类型
 	 * @return 流
 	 */
-	public static <T> EasyStream<T> of(Stream<T> stream) {
+	public static <T> EasyStream<T> of(final Stream<T> stream) {
-		return ObjUtil.isNull(stream) ? EasyStream.empty() : new EasyStream<>(stream);
+		return new EasyStream<>(stream);
 	}
 
 	/**
@@ -192,7 +230,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param next    用上一个元素作为参数执行并返回一个新的元素
 	 * @return 无限有序流
 	 */
-	public static <T> EasyStream<T> iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next) {
+	public static <T> EasyStream<T> iterate(final T seed, final Predicate<? super T> hasNext, final UnaryOperator<T> next) {
 		Objects.requireNonNull(next);
 		Objects.requireNonNull(hasNext);
 		return new EasyStream<>(StreamUtil.iterate(seed, hasNext, next));
@@ -207,7 +245,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param s   用来生成元素的 {@code Supplier}
 	 * @return 无限串行无序流
 	 */
-	public static <T> EasyStream<T> generate(Supplier<T> s) {
+	public static <T> EasyStream<T> generate(final Supplier<T> s) {
 		return new EasyStream<>(Stream.generate(s));
 	}
 
@@ -223,7 +261,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param b   第二个流
 	 * @return 拼接两个流之后的流
 	 */
-	public static <T> EasyStream<T> concat(Stream<? extends T> a, Stream<? extends T> b) {
+	public static <T> EasyStream<T> concat(final Stream<? extends T> a, final Stream<? extends T> b) {
 		return new EasyStream<>(Stream.concat(a, b));
 	}
 
@@ -234,7 +272,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param regex 正则
 	 * @return 拆分后元素组成的流
 	 */
-	public static EasyStream<String> split(CharSequence str, String regex) {
+	public static EasyStream<String> split(final CharSequence str, final String regex) {
 		return Opt.ofBlankAble(str).map(CharSequence::toString).map(s -> s.split(regex)).map(EasyStream::of).orElseGet(EasyStream::empty);
 	}
 
@@ -249,7 +287,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @return 返回叠加过滤操作后的流
 	 */
 	@Override
-	public EasyStream<T> filter(Predicate<? super T> predicate) {
+	public EasyStream<T> filter(final Predicate<? super T> predicate) {
 		return new EasyStream<>(stream.filter(predicate));
 	}
 
@@ -262,7 +300,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param value  用来匹配的值
 	 * @return 与 指定操作结果 匹配 指定值 的元素组成的流
 	 */
-	public <R> EasyStream<T> filter(Function<? super T, ? extends R> mapper, R value) {
+	public <R> EasyStream<T> filter(final Function<? super T, ? extends R> mapper, final R value) {
 		Objects.requireNonNull(mapper);
 		return filter(e -> Objects.equals(mapper.apply(e), value));
 	}
@@ -274,12 +312,12 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param predicate 断言
 	 * @return 返回叠加过滤操作后的流
 	 */
-	public EasyStream<T> filterIdx(BiPredicate<? super T, Integer> predicate) {
+	public EasyStream<T> filterIdx(final BiPredicate<? super T, Integer> predicate) {
 		Objects.requireNonNull(predicate);
 		if (isParallel()) {
 			return filter(e -> predicate.test(e, NOT_FOUND_INDEX));
 		} else {
-			MutableInt index = new MutableInt(NOT_FOUND_INDEX);
+			final MutableInt index = new MutableInt(NOT_FOUND_INDEX);
 			return filter(e -> predicate.test(e, index.incrementAndGet()));
 		}
 	}
@@ -302,7 +340,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @return 返回叠加操作后的流
 	 */
 	@Override
-	public <R> EasyStream<R> map(Function<? super T, ? extends R> mapper) {
+	public <R> EasyStream<R> map(final Function<? super T, ? extends R> mapper) {
 		return new EasyStream<>(stream.map(mapper));
 	}
 
@@ -318,7 +356,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param <R>    函数执行后返回的类型
 	 * @return 新元素组成的流
 	 */
-	public <R> EasyStream<R> mapNonNull(Function<? super T, ? extends R> mapper) {
+	public <R> EasyStream<R> mapNonNull(final Function<? super T, ? extends R> mapper) {
 		return nonNull().<R>map(mapper).nonNull();
 	}
 
@@ -330,12 +368,12 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param <R>    函数执行后返回的类型
 	 * @return 返回叠加操作后的流
 	 */
-	public <R> EasyStream<R> mapIdx(BiFunction<? super T, Integer, ? extends R> mapper) {
+	public <R> EasyStream<R> mapIdx(final BiFunction<? super T, Integer, ? extends R> mapper) {
 		Objects.requireNonNull(mapper);
 		if (isParallel()) {
 			return map(e -> mapper.apply(e, NOT_FOUND_INDEX));
 		} else {
-			MutableInt index = new MutableInt(NOT_FOUND_INDEX);
+			final MutableInt index = new MutableInt(NOT_FOUND_INDEX);
 			return map(e -> mapper.apply(e, index.incrementAndGet()));
 		}
 	}
@@ -353,7 +391,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @return 返回叠加拆分操作后的流
 	 */
 	@Override
-	public <R> EasyStream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper) {
+	public <R> EasyStream<R> flatMap(final Function<? super T, ? extends Stream<? extends R>> mapper) {
 		return new EasyStream<>(stream.flatMap(mapper));
 	}
 
@@ -365,12 +403,12 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param <R>    拆分后流的元素类型
 	 * @return 返回叠加拆分操作后的流
 	 */
-	public <R> EasyStream<R> flatMapIdx(BiFunction<? super T, Integer, ? extends Stream<? extends R>> mapper) {
+	public <R> EasyStream<R> flatMapIdx(final BiFunction<? super T, Integer, ? extends Stream<? extends R>> mapper) {
 		Objects.requireNonNull(mapper);
 		if (isParallel()) {
 			return flatMap(e -> mapper.apply(e, NOT_FOUND_INDEX));
 		} else {
-			MutableInt index = new MutableInt(NOT_FOUND_INDEX);
+			final MutableInt index = new MutableInt(NOT_FOUND_INDEX);
 			return flatMap(e -> mapper.apply(e, index.incrementAndGet()));
 		}
 	}
@@ -383,7 +421,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @return 叠加操作后元素类型全为int的流
 	 */
 	@Override
-	public IntStream mapToInt(ToIntFunction<? super T> mapper) {
+	public IntStream mapToInt(final ToIntFunction<? super T> mapper) {
 		return stream.mapToInt(mapper);
 	}
 
@@ -395,7 +433,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @return 叠加操作后元素类型全为long的流
 	 */
 	@Override
-	public LongStream mapToLong(ToLongFunction<? super T> mapper) {
+	public LongStream mapToLong(final ToLongFunction<? super T> mapper) {
 		return stream.mapToLong(mapper);
 	}
 
@@ -407,7 +445,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @return 叠加操作后元素类型全为double的流
 	 */
 	@Override
-	public DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper) {
+	public DoubleStream mapToDouble(final ToDoubleFunction<? super T> mapper) {
 		return stream.mapToDouble(mapper);
 	}
 
@@ -424,7 +462,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param <R>    拆分后流的元素类型
 	 * @return 返回叠加拆分操作后的流
 	 */
-	public <R> EasyStream<R> flat(Function<? super T, ? extends Iterable<? extends R>> mapper) {
+	public <R> EasyStream<R> flat(final Function<? super T, ? extends Iterable<? extends R>> mapper) {
 		Objects.requireNonNull(mapper);
 		return flatMap(w -> of(mapper.apply(w)));
 	}
@@ -440,7 +478,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @see #flat(Function)
 	 * @see #nonNull()
 	 */
-	public <R> EasyStream<R> flatNonNull(Function<? super T, ? extends Iterable<? extends R>> mapper) {
+	public <R> EasyStream<R> flatNonNull(final Function<? super T, ? extends Iterable<? extends R>> mapper) {
 		return nonNull().flat(mapper).nonNull();
 	}
 
@@ -452,7 +490,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @return 返回叠加拆分操作后的IntStream
 	 */
 	@Override
-	public IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper) {
+	public IntStream flatMapToInt(final Function<? super T, ? extends IntStream> mapper) {
 		return stream.flatMapToInt(mapper);
 	}
 
@@ -464,7 +502,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @return 返回叠加拆分操作后的LongStream
 	 */
 	@Override
-	public LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper) {
+	public LongStream flatMapToLong(final Function<? super T, ? extends LongStream> mapper) {
 		return stream.flatMapToLong(mapper);
 	}
 
@@ -476,7 +514,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @return 返回叠加拆分操作后的DoubleStream
 	 */
 	@Override
-	public DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper) {
+	public DoubleStream flatMapToDouble(final Function<? super T, ? extends DoubleStream> mapper) {
 		return stream.flatMapToDouble(mapper);
 	}
 
@@ -488,10 +526,10 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param <R>    拆分后流的元素类型
 	 * @return 返回叠加拆分操作后的流
 	 */
-	public <R> EasyStream<R> mapMulti(BiConsumer<? super T, ? super FastStreamBuilder<R>> mapper) {
+	public <R> EasyStream<R> mapMulti(final BiConsumer<? super T, ? super FastStreamBuilder<R>> mapper) {
 		Objects.requireNonNull(mapper);
 		return flatMap(e -> {
-			FastStreamBuilder<R> buffer = EasyStream.builder();
+			final FastStreamBuilder<R> buffer = EasyStream.builder();
 			mapper.accept(e, buffer);
 			return buffer.build();
 		});
@@ -516,15 +554,15 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param keyExtractor 去重依据
 	 * @return 一个具有去重特征的流
 	 */
-	public <F> EasyStream<T> distinct(Function<? super T, F> keyExtractor) {
+	public <F> EasyStream<T> distinct(final Function<? super T, F> keyExtractor) {
 		Objects.requireNonNull(keyExtractor);
 		if (isParallel()) {
-			ConcurrentHashMap<F, Boolean> exists = MapUtil.newConcurrentHashMap();
+			final ConcurrentHashMap<F, Boolean> exists = MapUtil.newConcurrentHashMap();
 			// 标记是否出现过null值，用于保留第一个出现的null
 			// 由于ConcurrentHashMap的key不能为null，所以用此变量来标记
-			AtomicBoolean hasNull = new AtomicBoolean(false);
+			final AtomicBoolean hasNull = new AtomicBoolean(false);
 			return of(stream.filter(e -> {
-				F key = keyExtractor.apply(e);
+				final F key = keyExtractor.apply(e);
 				if (key == null) {
 					// 已经出现过null值，跳过该值
 					if (hasNull.get()) {
@@ -538,7 +576,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 				}
 			})).parallel();
 		} else {
-			Set<F> exists = new HashSet<>();
+			final Set<F> exists = new HashSet<>();
 			return of(stream.filter(e -> exists.add(keyExtractor.apply(e))));
 		}
 	}
@@ -566,7 +604,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @return 一个元素按指定的Comparator排序的流
 	 */
 	@Override
-	public EasyStream<T> sorted(Comparator<? super T> comparator) {
+	public EasyStream<T> sorted(final Comparator<? super T> comparator) {
 		return new EasyStream<>(stream.sorted(comparator));
 	}
 
@@ -588,7 +626,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * }</pre>
 	 */
 	@Override
-	public EasyStream<T> peek(Consumer<? super T> action) {
+	public EasyStream<T> peek(final Consumer<? super T> action) {
 		return new EasyStream<>(stream.peek(action));
 	}
 
@@ -609,7 +647,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @return 截取后的流
 	 */
 	@Override
-	public EasyStream<T> limit(long maxSize) {
+	public EasyStream<T> limit(final long maxSize) {
 		return new EasyStream<>(stream.limit(maxSize));
 	}
 
@@ -621,7 +659,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @return 丢弃前面n个元素后的剩余元素组成的流
 	 */
 	@Override
-	public EasyStream<T> skip(long n) {
+	public EasyStream<T> skip(final long n) {
 		return new EasyStream<>(stream.skip(n));
 	}
 
@@ -644,7 +682,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param action 操作
 	 */
 	@Override
-	public void forEach(Consumer<? super T> action) {
+	public void forEach(final Consumer<? super T> action) {
 		stream.forEach(action);
 	}
 
@@ -654,12 +692,12 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 *
 	 * @param action 操作
 	 */
-	public void forEachIdx(BiConsumer<? super T, Integer> action) {
+	public void forEachIdx(final BiConsumer<? super T, Integer> action) {
 		Objects.requireNonNull(action);
 		if (isParallel()) {
 			stream.forEach(e -> action.accept(e, NOT_FOUND_INDEX));
 		} else {
-			MutableInt index = new MutableInt(NOT_FOUND_INDEX);
+			final MutableInt index = new MutableInt(NOT_FOUND_INDEX);
 			stream.forEach(e -> action.accept(e, index.incrementAndGet()));
 		}
 	}
@@ -671,7 +709,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param action 操作
 	 */
 	@Override
-	public void forEachOrdered(Consumer<? super T> action) {
+	public void forEachOrdered(final Consumer<? super T> action) {
 		stream.forEachOrdered(action);
 	}
 
@@ -681,12 +719,12 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 *
 	 * @param action 操作
 	 */
-	public void forEachOrderedIdx(BiConsumer<? super T, Integer> action) {
+	public void forEachOrderedIdx(final BiConsumer<? super T, Integer> action) {
 		Objects.requireNonNull(action);
 		if (isParallel()) {
 			stream.forEachOrdered(e -> action.accept(e, NOT_FOUND_INDEX));
 		} else {
-			MutableInt index = new MutableInt(NOT_FOUND_INDEX);
+			final MutableInt index = new MutableInt(NOT_FOUND_INDEX);
 			stream.forEachOrdered(e -> action.accept(e, index.incrementAndGet()));
 		}
 	}
@@ -712,7 +750,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @throws ArrayStoreException 如果元素转换失败，例如不是该元素类型及其父类，则抛出该异常
 	 */
 	@Override
-	public <A> A[] toArray(IntFunction<A[]> generator) {
+	public <A> A[] toArray(final IntFunction<A[]> generator) {
 		//noinspection SuspiciousToArrayCall
 		return stream.toArray(generator);
 	}
@@ -738,7 +776,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @return 聚合计算后的值
 	 */
 	@Override
-	public T reduce(T identity, BinaryOperator<T> accumulator) {
+	public T reduce(final T identity, final BinaryOperator<T> accumulator) {
 		return stream.reduce(identity, accumulator);
 	}
 
@@ -773,7 +811,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @see #max(Comparator)
 	 */
 	@Override
-	public Optional<T> reduce(BinaryOperator<T> accumulator) {
+	public Optional<T> reduce(final BinaryOperator<T> accumulator) {
 		return stream.reduce(accumulator);
 	}
 
@@ -790,7 +828,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @see #reduce(Object, BinaryOperator)
 	 */
 	@Override
-	public <U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner) {
+	public <U> U reduce(final U identity, final BiFunction<U, ? super T, U> accumulator, final BinaryOperator<U> combiner) {
 		return stream.reduce(identity, accumulator, combiner);
 	}
 
@@ -808,7 +846,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * }</pre>
 	 */
 	@Override
-	public <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner) {
+	public <R> R collect(final Supplier<R> supplier, final BiConsumer<R, ? super T> accumulator, final BiConsumer<R, R> combiner) {
 		return stream.collect(supplier, accumulator, combiner);
 	}
 
@@ -822,7 +860,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @return 收集后的容器
 	 */
 	@Override
-	public <R, A> R collect(Collector<? super T, A, R> collector) {
+	public <R, A> R collect(final Collector<? super T, A, R> collector) {
 		return stream.collect(collector);
 	}
 
@@ -833,7 +871,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @return 最小值
 	 */
 	@Override
-	public Optional<T> min(Comparator<? super T> comparator) {
+	public Optional<T> min(final Comparator<? super T> comparator) {
 		return stream.min(comparator);
 	}
 
@@ -844,7 +882,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @return 最大值
 	 */
 	@Override
-	public Optional<T> max(Comparator<? super T> comparator) {
+	public Optional<T> max(final Comparator<? super T> comparator) {
 		return stream.max(comparator);
 	}
 
@@ -865,7 +903,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @return 是否有任何一个元素满足给定断言
 	 */
 	@Override
-	public boolean anyMatch(Predicate<? super T> predicate) {
+	public boolean anyMatch(final Predicate<? super T> predicate) {
 		return stream.anyMatch(predicate);
 	}
 
@@ -876,7 +914,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @return 是否所有元素满足给定断言
 	 */
 	@Override
-	public boolean allMatch(Predicate<? super T> predicate) {
+	public boolean allMatch(final Predicate<? super T> predicate) {
 		return stream.allMatch(predicate);
 	}
 
@@ -887,7 +925,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @return 是否没有元素满足给定断言
 	 */
 	@Override
-	public boolean noneMatch(Predicate<? super T> predicate) {
+	public boolean noneMatch(final Predicate<? super T> predicate) {
 		return stream.noneMatch(predicate);
 	}
 
@@ -907,7 +945,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param predicate 断言
 	 * @return 与给定断言匹配的第一个元素
 	 */
-	public Optional<T> findFirst(Predicate<? super T> predicate) {
+	public Optional<T> findFirst(final Predicate<? super T> predicate) {
 		return stream.filter(predicate).findFirst();
 	}
 
@@ -917,12 +955,12 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param predicate 断言
 	 * @return 与给定断言匹配的第一个元素的下标，如果不存在则返回-1
 	 */
-	public int findFirstIdx(Predicate<? super T> predicate) {
+	public int findFirstIdx(final Predicate<? super T> predicate) {
 		Objects.requireNonNull(predicate);
 		if (isParallel()) {
 			return NOT_FOUND_INDEX;
 		} else {
-			MutableInt index = new MutableInt(NOT_FOUND_INDEX);
+			final MutableInt index = new MutableInt(NOT_FOUND_INDEX);
 			//noinspection ResultOfMethodCallIgnored
 			stream.filter(e -> {
 				index.increment();
@@ -938,7 +976,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @return 最后一个元素
 	 */
 	public Optional<T> findLast() {
-		MutableObj<T> last = new MutableObj<>(null);
+		final MutableObj<T> last = new MutableObj<>(null);
 		spliterator().forEachRemaining(last::set);
 		return Optional.ofNullable(last.get());
 	}
@@ -949,9 +987,9 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param predicate 断言
 	 * @return 与给定断言匹配的最后一个元素
 	 */
-	public Optional<T> findLast(Predicate<? super T> predicate) {
+	public Optional<T> findLast(final Predicate<? super T> predicate) {
 		Objects.requireNonNull(predicate);
-		MutableObj<T> last = new MutableObj<>(null);
+		final MutableObj<T> last = new MutableObj<>(null);
 		spliterator().forEachRemaining(e -> {
 			if (predicate.test(e)) {
 				last.set(e);
@@ -966,12 +1004,12 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param predicate 断言
 	 * @return 与给定断言匹配的最后一个元素的下标，如果不存在则返回-1
 	 */
-	public int findLastIdx(Predicate<? super T> predicate) {
+	public int findLastIdx(final Predicate<? super T> predicate) {
 		Objects.requireNonNull(predicate);
 		if (isParallel()) {
 			return NOT_FOUND_INDEX;
 		} else {
-			MutableInt idxRef = new MutableInt(NOT_FOUND_INDEX);
+			final MutableInt idxRef = new MutableInt(NOT_FOUND_INDEX);
 			forEachIdx((e, i) -> {
 				if (predicate.test(e)) {
 					idxRef.set(i);
@@ -1041,7 +1079,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param parallel 是否并行
 	 * @return 流
 	 */
-	public EasyStream<T> parallel(boolean parallel) {
+	public EasyStream<T> parallel(final boolean parallel) {
 		return parallel ? parallel() : sequential();
 	}
 
@@ -1063,7 +1101,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @return 流
 	 */
 	@Override
-	public EasyStream<T> onClose(Runnable closeHandler) {
+	public EasyStream<T> onClose(final Runnable closeHandler) {
 		//noinspection ResultOfMethodCallIgnored
 		stream.onClose(closeHandler);
 		return this;
@@ -1075,7 +1113,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param obj 元素
 	 * @return 流
 	 */
-	public EasyStream<T> push(T obj) {
+	public EasyStream<T> push(final T obj) {
 		return EasyStream.concat(this.stream, of(obj));
 	}
 
@@ -1086,7 +1124,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @return 流
 	 */
 	@SuppressWarnings("unchecked")
-	public EasyStream<T> push(T... obj) {
+	public EasyStream<T> push(final T... obj) {
 		return EasyStream.concat(this.stream, of(obj));
 	}
 
@@ -1096,7 +1134,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param obj 元素
 	 * @return 流
 	 */
-	public EasyStream<T> unshift(T obj) {
+	public EasyStream<T> unshift(final T obj) {
 		return EasyStream.concat(of(obj), this.stream);
 	}
 
@@ -1107,7 +1145,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @return 流
 	 */
 	@SafeVarargs
-	public final EasyStream<T> unshift(T... obj) {
+	public final EasyStream<T> unshift(final T... obj) {
 		return EasyStream.concat(of(obj), this.stream);
 	}
 
@@ -1117,7 +1155,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param idx 下标
 	 * @return 指定下标的元素
 	 */
-	public Optional<T> at(Integer idx) {
+	public Optional<T> at(final Integer idx) {
 		return Opt.ofNullable(idx).map(i -> {
 			//noinspection unchecked
 			return (T) ArrayUtil.get(toArray(), i);
@@ -1161,7 +1199,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @return 结果
 	 */
 	@Override
-	public boolean equals(Object obj) {
+	public boolean equals(final Object obj) {
 		if (obj instanceof Stream) {
 			return stream.equals(obj);
 		}
@@ -1185,7 +1223,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param <C>               集合类型
 	 * @return 集合
 	 */
-	public <C extends Collection<T>> C toColl(Supplier<C> collectionFactory) {
+	public <C extends Collection<T>> C toColl(final Supplier<C> collectionFactory) {
 		return collect(Collectors.toCollection(collectionFactory));
 	}
 
@@ -1215,7 +1253,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param <R>   可迭代对象迭代的元素类型
 	 * @return map，key为现有元素，value为给定可迭代对象迭代的元素
 	 */
-	public <R> Map<T, R> toZip(Iterable<R> other) {
+	public <R> Map<T, R> toZip(final Iterable<R> other) {
 		final Spliterator<T> keys = spliterator();
 		final Spliterator<R> values = Opt.ofNullable(other).map(Iterable::spliterator).orElseGet(Spliterators::emptySpliterator);
 		// 获取两个Spliterator的中较小的数量
@@ -1223,9 +1261,9 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 		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<>();
+		final MutableObj<T> key = new MutableObj<>();
 		// 保存第二个Spliterator的值
-		MutableObj<R> value = new MutableObj<>();
+		final MutableObj<R> value = new MutableObj<>();
 		// 当两个Spliterator中都还有剩余元素时
 		while (keys.tryAdvance(key::set) && values.tryAdvance(value::set)) {
 			map.put(key.get(), value.get());
@@ -1248,7 +1286,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param delimiter 分隔符
 	 * @return 拼接后的字符串
 	 */
-	public String join(CharSequence delimiter) {
+	public String join(final CharSequence delimiter) {
 		return join(delimiter, StrUtil.EMPTY, StrUtil.EMPTY);
 	}
 
@@ -1260,9 +1298,9 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param suffix    后缀
 	 * @return 拼接后的字符串
 	 */
-	public String join(CharSequence delimiter,
+	public String join(final CharSequence delimiter,
-					   CharSequence prefix,
+					   final CharSequence prefix,
-					   CharSequence suffix) {
+					   final CharSequence suffix) {
 		return map(String::valueOf).collect(Collectors.joining(delimiter, prefix, suffix));
 	}
 
@@ -1273,7 +1311,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param <K>       key类型
 	 * @return map
 	 */
-	public <K> Map<K, T> toMap(Function<? super T, ? extends K> keyMapper) {
+	public <K> Map<K, T> toMap(final Function<? super T, ? extends K> keyMapper) {
 		return toMap(keyMapper, Function.identity());
 	}
 
@@ -1286,8 +1324,8 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param <U>         value类型
 	 * @return map
 	 */
-	public <K, U> Map<K, U> toMap(Function<? super T, ? extends K> keyMapper,
+	public <K, U> Map<K, U> toMap(final Function<? super T, ? extends K> keyMapper,
-								  Function<? super T, ? extends U> valueMapper) {
+								  final Function<? super T, ? extends U> valueMapper) {
 		return toMap(keyMapper, valueMapper, (l, r) -> r);
 	}
 
@@ -1301,9 +1339,9 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param <U>           value类型
 	 * @return map
 	 */
-	public <K, U> Map<K, U> toMap(Function<? super T, ? extends K> keyMapper,
+	public <K, U> Map<K, U> toMap(final Function<? super T, ? extends K> keyMapper,
-								  Function<? super T, ? extends U> valueMapper,
+								  final Function<? super T, ? extends U> valueMapper,
-								  BinaryOperator<U> mergeFunction) {
+								  final BinaryOperator<U> mergeFunction) {
 		return toMap(keyMapper, valueMapper, mergeFunction, HashMap::new);
 	}
 
@@ -1319,10 +1357,10 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param <M>           map类型
 	 * @return map
 	 */
-	public <K, U, M extends Map<K, U>> M toMap(Function<? super T, ? extends K> keyMapper,
+	public <K, U, M extends Map<K, U>> M toMap(final Function<? super T, ? extends K> keyMapper,
-											   Function<? super T, ? extends U> valueMapper,
+											   final Function<? super T, ? extends U> valueMapper,
-											   BinaryOperator<U> mergeFunction,
+											   final BinaryOperator<U> mergeFunction,
-											   Supplier<M> mapSupplier) {
+											   final Supplier<M> mapSupplier) {
 		return collect(CollectorUtil.toMap(keyMapper, valueMapper, mergeFunction, mapSupplier));
 	}
 
@@ -1334,7 +1372,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param <K>        实体中的分组依据对应类型，也是Map中key的类型
 	 * @return {@link Collector}
 	 */
-	public <K> Map<K, List<T>> group(Function<? super T, ? extends K> classifier) {
+	public <K> Map<K, List<T>> group(final Function<? super T, ? extends K> classifier) {
 		return group(classifier, Collectors.toList());
 	}
 
@@ -1348,8 +1386,8 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param <A>        下游操作在进行中间操作时对应类型
 	 * @return {@link Collector}
 	 */
-	public <K, A, D> Map<K, D> group(Function<? super T, ? extends K> classifier,
+	public <K, A, D> Map<K, D> group(final Function<? super T, ? extends K> classifier,
-									 Collector<? super T, A, D> downstream) {
+									 final Collector<? super T, A, D> downstream) {
 		return group(classifier, HashMap::new, downstream);
 	}
 
@@ -1365,9 +1403,9 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param <M>        最后返回结果Map类型
 	 * @return {@link Collector}
 	 */
-	public <K, D, A, M extends Map<K, D>> M group(Function<? super T, ? extends K> classifier,
+	public <K, D, A, M extends Map<K, D>> M group(final Function<? super T, ? extends K> classifier,
-												  Supplier<M> mapFactory,
+												  final Supplier<M> mapFactory,
-												  Collector<? super T, A, D> downstream) {
+												  final Collector<? super T, A, D> downstream) {
 		return collect(CollectorUtil.groupingBy(classifier, mapFactory, downstream));
 	}
 
@@ -1381,8 +1419,8 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param <R>    合并后的结果对象类型
 	 * @return 合并后的结果对象的流
 	 */
-	public <U, R> EasyStream<R> zip(Iterable<U> other,
+	public <U, R> EasyStream<R> zip(final Iterable<U> other,
-									BiFunction<? super T, ? super U, ? extends R> zipper) {
+									final BiFunction<? super T, ? super U, ? extends R> zipper) {
 		Objects.requireNonNull(zipper);
 		final Spliterator<T> keys = spliterator();
 		final Spliterator<U> values = Opt.ofNullable(other).map(Iterable::spliterator).orElseGet(Spliterators::emptySpliterator);
@@ -1391,9 +1429,9 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 		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<>();
+		final MutableObj<T> key = new MutableObj<>();
 		// 保存第二个Spliterator的值
-		MutableObj<U> value = new MutableObj<>();
+		final MutableObj<U> value = new MutableObj<>();
 		// 当两个Spliterator中都还有剩余元素时
 		while (keys.tryAdvance(key::set) && values.tryAdvance(value::set)) {
 			list.add(zipper.apply(key.get(), value.get()));
@@ -1410,7 +1448,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @return 操作后的流
 	 */
 	@SafeVarargs
-	public final EasyStream<T> splice(int start, int deleteCount, T... items) {
+	public final EasyStream<T> splice(final int start, final int deleteCount, final T... items) {
 		return of(ListUtil.splice(toList(), start, deleteCount, items))
 				.parallel(isParallel())
 				.onClose(stream::close);
@@ -1426,7 +1464,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @return 切好的流
 	 */
 	public EasyStream<EasyStream<T>> split(final int batchSize) {
-		List<T> list = toList();
+		final List<T> list = toList();
 		final int size = list.size();
 		// 指定长度 大于等于 列表长度
 		if (size <= batchSize) {
@@ -1471,7 +1509,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param predicate 断言
 	 * @return 与指定断言匹配的元素组成的流
 	 */
-	public EasyStream<T> takeWhile(Predicate<? super T> predicate) {
+	public EasyStream<T> takeWhile(final Predicate<? super T> predicate) {
 		Objects.requireNonNull(predicate);
 		return of(StreamUtil.takeWhile(stream, predicate));
 	}
@@ -1496,7 +1534,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param predicate 断言
 	 * @return 剩余元素组成的流
 	 */
-	public EasyStream<T> dropWhile(Predicate<? super T> predicate) {
+	public EasyStream<T> dropWhile(final Predicate<? super T> predicate) {
 		Objects.requireNonNull(predicate);
 		return of(StreamUtil.dropWhile(stream, predicate));
 	}
@@ -1526,7 +1564,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 	 * @param transform 转换
 	 * @return 转换后的流
 	 */
-	public <R> Optional<R> transform(Function<EasyStream<T>, R> transform) {
+	public <R> Optional<R> transform(final Function<EasyStream<T>, R> transform) {
 		Assert.notNull(transform, "transform must not null");
 		return Optional.ofNullable(transform.apply(this));
 	}
@@ -1546,7 +1584,7 @@ public class EasyStream<T> implements Stream<T>, Iterable<T> {
 		 *     return this;
 		 * }</pre>
 		 */
-		default FastStreamBuilder<T> add(T t) {
+		default FastStreamBuilder<T> add(final T t) {
 			accept(t);
 			return this;
 		}

hutool-core/src/test/java/cn/hutool/core/collection/CollUtilTest.java

@@ -1,7 +1,7 @@
 package cn.hutool.core.collection;
 
 import cn.hutool.core.collection.iter.IterUtil;
-import cn.hutool.core.comparator.ComparableComparator;
+import cn.hutool.core.comparator.CompareUtil;
 import cn.hutool.core.date.DateUtil;
 import cn.hutool.core.lang.Console;
 import cn.hutool.core.map.Dict;
@@ -858,9 +858,9 @@ public class CollUtilTest {
 	}
 
 	@Test
-	public void sortComparableTest() {
+	public void sortNaturalTest() {
 		final List<String> of = ListUtil.of("a", "c", "b");
-		final List<String> sort = CollUtil.sort(of, new ComparableComparator<>());
+		final List<String> sort = CollUtil.sort(of, CompareUtil.natural());
 		Assert.assertEquals("a,b,c", CollUtil.join(sort, ","));
 	}
 

hutool-core/src/test/java/cn/hutool/core/stream/EasyStreamTest.java

@@ -19,13 +19,13 @@ public class EasyStreamTest {
 
 	@Test
 	public void testBuilder() {
-		List<Integer> list = EasyStream.<Integer>builder().add(1).add(2).add(3).build().toList();
+		final List<Integer> list = EasyStream.<Integer>builder().add(1).add(2).add(3).build().toList();
 		Assert.assertEquals(Arrays.asList(1, 2, 3), list);
 	}
 
 	@Test
 	public void testGenerate() {
-		List<Integer> list = EasyStream.generate(() -> 0).limit(3).toList();
+		final List<Integer> list = EasyStream.generate(() -> 0).limit(3).toList();
 		Assert.assertEquals(Arrays.asList(0, 0, 0), list);
 	}
 
@@ -38,58 +38,58 @@ public class EasyStreamTest {
 
 	@Test
 	public void testSplit() {
-		List<Integer> list = EasyStream.split("1,2,3", ",").map(Integer::valueOf).toList();
+		final List<Integer> list = EasyStream.split("1,2,3", ",").map(Integer::valueOf).toList();
 		Assert.assertEquals(Arrays.asList(1, 2, 3), list);
 	}
 
 	@Test
 	public void testIterator() {
-		List<Integer> list = EasyStream.iterate(0, i -> i < 3, i -> ++i).toList();
+		final List<Integer> list = EasyStream.iterate(0, i -> i < 3, i -> ++i).toList();
 		Assert.assertEquals(Arrays.asList(0, 1, 2), list);
 	}
 
 	@Test
 	public void testToCollection() {
-		List<Integer> list = Arrays.asList(1, 2, 3);
+		final List<Integer> list = Arrays.asList(1, 2, 3);
-		List<String> toCollection = EasyStream.of(list).map(String::valueOf).toColl(LinkedList::new);
+		final List<String> toCollection = EasyStream.of(list).map(String::valueOf).toColl(LinkedList::new);
 		Assert.assertEquals(Arrays.asList("1", "2", "3"), toCollection);
 	}
 
 	@Test
 	public void testToList() {
-		List<Integer> list = Arrays.asList(1, 2, 3);
+		final List<Integer> list = Arrays.asList(1, 2, 3);
-		List<String> toList = EasyStream.of(list).map(String::valueOf).toList();
+		final List<String> toList = EasyStream.of(list).map(String::valueOf).toList();
 		Assert.assertEquals(Arrays.asList("1", "2", "3"), toList);
 	}
 
 	@Test
 	public void testToSet() {
-		List<Integer> list = Arrays.asList(1, 2, 3);
+		final List<Integer> list = Arrays.asList(1, 2, 3);
-		Set<String> toSet = EasyStream.of(list).map(String::valueOf).toSet();
+		final Set<String> toSet = EasyStream.of(list).map(String::valueOf).toSet();
 		Assert.assertEquals(new HashSet<>(Arrays.asList("1", "2", "3")), toSet);
 	}
 
 	@Test
 	public void testToZip() {
-		List<Integer> orders = Arrays.asList(1, 2, 3, 2);
+		final List<Integer> orders = Arrays.asList(1, 2, 3, 2);
-		List<String> list = Arrays.asList("dromara", "guava", "sweet", "hutool");
+		final List<String> list = Arrays.asList("dromara", "guava", "sweet", "hutool");
 		final Map<Integer, String> map = MapUtil.<Integer, String>builder()
 				.put(1, "dromara")
 				.put(2, "hutool")
 				.put(3, "sweet")
 				.build();
 
-		Map<Integer, String> toZip = EasyStream.of(orders).toZip(list);
+		final Map<Integer, String> toZip = EasyStream.of(orders).toZip(list);
 		Assert.assertEquals(map, toZip);
 
-		Map<Integer, String> toZipParallel = EasyStream.of(orders).parallel().nonNull().toZip(list);
+		final Map<Integer, String> toZipParallel = EasyStream.of(orders).parallel().nonNull().toZip(list);
 		Assert.assertEquals(map, toZipParallel);
 	}
 
 	@Test
 	public void testJoin() {
-		List<Integer> list = Arrays.asList(1, 2, 3);
+		final List<Integer> list = Arrays.asList(1, 2, 3);
-		String joining = EasyStream.of(list).join();
+		final String joining = EasyStream.of(list).join();
 		Assert.assertEquals("123", joining);
 		Assert.assertEquals("1,2,3", EasyStream.of(list).join(","));
 		Assert.assertEquals("(1,2,3)", EasyStream.of(list).join(",", "(", ")"));
@@ -97,8 +97,8 @@ public class EasyStreamTest {
 
 	@Test
 	public void testToMap() {
-		List<Integer> list = Arrays.asList(1, 2, 3);
+		final List<Integer> list = Arrays.asList(1, 2, 3);
-		Map<String, Integer> identityMap = EasyStream.of(list).toMap(String::valueOf);
+		final Map<String, Integer> identityMap = EasyStream.of(list).toMap(String::valueOf);
 		Assert.assertEquals(new HashMap<String, Integer>() {
 			private static final long serialVersionUID = 1L;
 
@@ -112,8 +112,8 @@ public class EasyStreamTest {
 
 	@Test
 	public void testGroup() {
-		List<Integer> list = Arrays.asList(1, 2, 3);
+		final List<Integer> list = Arrays.asList(1, 2, 3);
-		Map<String, List<Integer>> group = EasyStream.of(list).group(String::valueOf);
+		final Map<String, List<Integer>> group = EasyStream.of(list).group(String::valueOf);
 		Assert.assertEquals(
 				new HashMap<String, List<Integer>>() {
 					private static final long serialVersionUID = 1L;
@@ -128,8 +128,8 @@ public class EasyStreamTest {
 
 	@Test
 	public void testMapIdx() {
-		List<String> list = Arrays.asList("dromara", "hutool", "sweet");
+		final List<String> list = Arrays.asList("dromara", "hutool", "sweet");
-		List<String> mapIndex = EasyStream.of(list).mapIdx((e, i) -> i + 1 + "." + e).toList();
+		final List<String> mapIndex = EasyStream.of(list).mapIdx((e, i) -> i + 1 + "." + e).toList();
 		Assert.assertEquals(Arrays.asList("1.dromara", "2.hutool", "3.sweet"), mapIndex);
 		// 并行流时为-1
 		Assert.assertEquals(Arrays.asList(-1, -1, -1), EasyStream.of(1, 2, 3).parallel().mapIdx((e, i) -> i).toList());
@@ -137,8 +137,8 @@ public class EasyStreamTest {
 
 	@Test
 	public void testMapMulti() {
-		List<Integer> list = Arrays.asList(1, 2, 3);
+		final List<Integer> list = Arrays.asList(1, 2, 3);
-		List<Integer> mapMulti = EasyStream.of(list).<Integer>mapMulti((e, buffer) -> {
+		final List<Integer> mapMulti = EasyStream.of(list).<Integer>mapMulti((e, buffer) -> {
 			for (int i = 0; i < e; i++) {
 				buffer.accept(e);
 			}
@@ -148,24 +148,24 @@ public class EasyStreamTest {
 
 	@Test
 	public void testMapNonNull() {
-		List<Integer> list = Arrays.asList(1, 2, 3, null);
+		final List<Integer> list = Arrays.asList(1, 2, 3, null);
-		List<String> mapNonNull = EasyStream.of(list).mapNonNull(String::valueOf).toList();
+		final List<String> mapNonNull = EasyStream.of(list).mapNonNull(String::valueOf).toList();
 		Assert.assertEquals(Arrays.asList("1", "2", "3"), mapNonNull);
 	}
 
 	@Test
 	public void testDistinct() {
-		List<Integer> list = ListUtil.of(3, 2, 2, 1, null, null);
+		final List<Integer> list = ListUtil.of(3, 2, 2, 1, null, null);
 		for (int i = 0; i < 1000; i++) {
 			list.add(i);
 		}
 		// 使用stream去重
-		List<Integer> collect1 = list.stream().distinct().collect(Collectors.toList());
+		final List<Integer> collect1 = list.stream().distinct().collect(Collectors.toList());
-		List<Integer> collect2 = list.stream().parallel().distinct().collect(Collectors.toList());
+		final List<Integer> collect2 = list.stream().parallel().distinct().collect(Collectors.toList());
 
 		// 使用FastStream去重
-		List<Integer> distinctBy1 = EasyStream.of(list).distinct().toList();
+		final List<Integer> distinctBy1 = EasyStream.of(list).distinct().toList();
-		List<Integer> distinctBy2 = EasyStream.of(list).parallel().distinct(String::valueOf).toList();
+		final List<Integer> distinctBy2 = EasyStream.of(list).parallel().distinct(String::valueOf).toList();
 
 		Assert.assertEquals(collect1, distinctBy1);
 		Assert.assertEquals(collect2, distinctBy2);
@@ -173,8 +173,8 @@ public class EasyStreamTest {
 
 	@Test
 	public void testForeachIdx() {
-		List<String> list = Arrays.asList("dromara", "hutool", "sweet");
+		final List<String> list = Arrays.asList("dromara", "hutool", "sweet");
-		EasyStream.FastStreamBuilder<String> builder = EasyStream.builder();
+		final EasyStream.FastStreamBuilder<String> builder = EasyStream.builder();
 		EasyStream.of(list).forEachIdx((e, i) -> builder.accept(i + 1 + "." + e));
 		Assert.assertEquals(Arrays.asList("1.dromara", "2.hutool", "3.sweet"), builder.build().toList());
 		// 并行流时为-1
@@ -183,12 +183,12 @@ public class EasyStreamTest {
 
 	@Test
 	public void testForEachOrderedIdx() {
-		List<String> list = Arrays.asList("dromara", "hutool", "sweet");
+		final List<String> list = Arrays.asList("dromara", "hutool", "sweet");
-		EasyStream.FastStreamBuilder<String> builder = EasyStream.builder();
+		final EasyStream.FastStreamBuilder<String> builder = EasyStream.builder();
 		EasyStream.of(list).forEachOrderedIdx((e, i) -> builder.accept(i + 1 + "." + e));
 		Assert.assertEquals(Arrays.asList("1.dromara", "2.hutool", "3.sweet"), builder.build().toList());
 
-		EasyStream.FastStreamBuilder<String> streamBuilder = EasyStream.builder();
+		final EasyStream.FastStreamBuilder<String> streamBuilder = EasyStream.builder();
 		EasyStream.of(list).parallel().forEachOrderedIdx((e, i) -> streamBuilder.accept(i + 1 + "." + e));
 		Assert.assertEquals(Arrays.asList("0.dromara", "0.hutool", "0.sweet"), streamBuilder.build().toList());
 
@@ -196,8 +196,8 @@ public class EasyStreamTest {
 
 	@Test
 	public void testFlatMapIdx() {
-		List<String> list = Arrays.asList("dromara", "hutool", "sweet");
+		final List<String> list = Arrays.asList("dromara", "hutool", "sweet");
-		List<String> mapIndex = EasyStream.of(list).flatMapIdx((e, i) -> EasyStream.of(i + 1 + "." + e)).toList();
+		final 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);
 		// 并行流时为-1
 		Assert.assertEquals(Arrays.asList(-1, -1, -1), EasyStream.of(1, 2, 3).parallel().flatMapIdx((e, i) -> EasyStream.of(i)).toList());
@@ -205,7 +205,7 @@ public class EasyStreamTest {
 
 	@Test
 	public void testFlat() {
-		List<Integer> list = Arrays.asList(1, 2, 3);
+		final List<Integer> list = Arrays.asList(1, 2, 3);
 
 		// 一个元素 扩散为 多个元素(迭代器)
 		List<Integer> flat = EasyStream.of(list).flat(e -> Arrays.asList(e, e * 10)).toList();
@@ -224,15 +224,15 @@ public class EasyStreamTest {
 
 	@Test
 	public void testFilter() {
-		List<Integer> list = Arrays.asList(1, 2, 3);
+		final List<Integer> list = Arrays.asList(1, 2, 3);
-		List<Integer> filterIndex = EasyStream.of(list).filter(String::valueOf, "1").toList();
+		final List<Integer> filterIndex = EasyStream.of(list).filter(String::valueOf, "1").toList();
 		Assert.assertEquals(Collections.singletonList(1), filterIndex);
 	}
 
 	@Test
 	public void testFilterIdx() {
-		List<String> list = Arrays.asList("dromara", "hutool", "sweet");
+		final List<String> list = Arrays.asList("dromara", "hutool", "sweet");
-		List<String> filterIndex = EasyStream.of(list).filterIdx((e, i) -> i < 2).toList();
+		final List<String> filterIndex = EasyStream.of(list).filterIdx((e, i) -> i < 2).toList();
 		Assert.assertEquals(Arrays.asList("dromara", "hutool"), filterIndex);
 		// 并行流时为-1
 		Assert.assertEquals(3L, EasyStream.of(1, 2, 3).parallel().filterIdx((e, i) -> i == -1).count());
@@ -240,8 +240,8 @@ public class EasyStreamTest {
 
 	@Test
 	public void testNonNull() {
-		List<Integer> list = Arrays.asList(1, null, 2, 3);
+		final List<Integer> list = Arrays.asList(1, null, 2, 3);
-		List<Integer> nonNull = EasyStream.of(list).nonNull().toList();
+		final List<Integer> nonNull = EasyStream.of(list).nonNull().toList();
 		Assert.assertEquals(Arrays.asList(1, 2, 3), nonNull);
 	}
 
@@ -253,8 +253,8 @@ public class EasyStreamTest {
 
 	@Test
 	public void testPush() {
-		List<Integer> list = Arrays.asList(1, 2);
+		final List<Integer> list = Arrays.asList(1, 2);
-		List<Integer> push = EasyStream.of(list).push(3).toList();
+		final List<Integer> push = EasyStream.of(list).push(3).toList();
 		Assert.assertEquals(Arrays.asList(1, 2, 3), push);
 
 		Assert.assertEquals(Arrays.asList(1, 2, 3, 4), EasyStream.of(list).push(3, 4).toList());
@@ -262,8 +262,8 @@ public class EasyStreamTest {
 
 	@Test
 	public void testUnshift() {
-		List<Integer> list = Arrays.asList(2, 3);
+		final List<Integer> list = Arrays.asList(2, 3);
-		List<Integer> unshift = EasyStream.of(list).unshift(1).toList();
+		final List<Integer> unshift = EasyStream.of(list).unshift(1).toList();
 		Assert.assertEquals(Arrays.asList(1, 2, 3), unshift);
 
 		Assert.assertEquals(Arrays.asList(1, 2, 2, 3), EasyStream.of(list).unshift(1, 2).toList());
@@ -271,7 +271,7 @@ public class EasyStreamTest {
 
 	@Test
 	public void testAt() {
-		List<Integer> list = Arrays.asList(1, 2, 3);
+		final List<Integer> list = Arrays.asList(1, 2, 3);
 		Assert.assertEquals(1, (Object) EasyStream.of(list).at(0).orElse(null));
 		Assert.assertEquals(2, (Object) EasyStream.of(list).at(1).orElse(null));
 		Assert.assertEquals(3, (Object) EasyStream.of(list).at(2).orElse(null));
@@ -282,7 +282,7 @@ public class EasyStreamTest {
 
 	@Test
 	public void testSplice() {
-		List<Integer> list = Arrays.asList(1, 2, 3);
+		final List<Integer> list = Arrays.asList(1, 2, 3);
 		Assert.assertEquals(Arrays.asList(1, 2, 2, 3), EasyStream.of(list).splice(1, 0, 2).toList());
 		Assert.assertEquals(Arrays.asList(1, 2, 3, 3), EasyStream.of(list).splice(3, 1, 3).toList());
 		Assert.assertEquals(Arrays.asList(1, 2, 4), EasyStream.of(list).splice(2, 1, 4).toList());
@@ -294,25 +294,25 @@ public class EasyStreamTest {
 
 	@Test
 	public void testFindFirst() {
-		List<Integer> list = Arrays.asList(1, 2, 3);
+		final List<Integer> list = Arrays.asList(1, 2, 3);
-		Integer find = EasyStream.of(list).findFirst(Objects::nonNull).orElse(null);
+		final Integer find = EasyStream.of(list).findFirst(Objects::nonNull).orElse(null);
 		Assert.assertEquals(1, (Object) find);
 	}
 
 	@Test
 	public void testFindFirstIdx() {
-		List<Integer> list = Arrays.asList(null, 2, 3);
+		final List<Integer> list = Arrays.asList(null, 2, 3);
 		Assert.assertEquals(1, EasyStream.of(list).findFirstIdx(Objects::nonNull));
 		Assert.assertEquals(-1, (Object) EasyStream.of(list).parallel().findFirstIdx(Objects::nonNull));
 	}
 
 	@Test
 	public void testFindLast() {
-		List<Integer> list = ListUtil.of(1, 2, 4, 5, 6, 7, 8, 9, 10, 3);
+		final List<Integer> list = ListUtil.of(1, 2, 4, 5, 6, 7, 8, 9, 10, 3);
 		Assert.assertEquals(3, (Object) EasyStream.of(list).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);
+		final List<Integer> list2 = ListUtil.of(1, 2, 4, 5, 6, 7, 8, 9, 10, 3, null);
 		Assert.assertEquals(3, (Object) EasyStream.of(list2).parallel().findLast(Objects::nonNull).orElse(null));
 
 		Assert.assertNull(EasyStream.of().parallel().findLast(Objects::nonNull).orElse(null));
@@ -321,7 +321,7 @@ public class EasyStreamTest {
 
 	@Test
 	public void testFindLastIdx() {
-		List<Integer> list = Arrays.asList(1, null, 3);
+		final List<Integer> list = Arrays.asList(1, null, 3);
 		Assert.assertEquals(2, (Object) EasyStream.of(list).findLastIdx(Objects::nonNull));
 		Assert.assertEquals(-1, (Object) EasyStream.of(list).parallel().findLastIdx(Objects::nonNull));
 	}
@@ -337,8 +337,8 @@ public class EasyStreamTest {
 
 	@Test
 	public void testZip() {
-		List<Integer> orders = Arrays.asList(1, 2, 3);
+		final List<Integer> orders = Arrays.asList(1, 2, 3);
-		List<String> list = Arrays.asList("dromara", "hutool", "sweet");
+		final List<String> list = Arrays.asList("dromara", "hutool", "sweet");
 		List<String> zip = EasyStream.of(orders).zip(list, (e1, e2) -> e1 + "." + e2).toList();
 		Assert.assertEquals(Arrays.asList("1.dromara", "2.hutool", "3.sweet"), zip);
 
@@ -348,7 +348,7 @@ public class EasyStreamTest {
 
 	@Test
 	public void testListSplit() {
-		List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
+		final List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
 		List<List<Integer>> lists = EasyStream.of(list).split(2).map(EasyStream::toList).toList();
 		Assert.assertEquals(ListUtil.split(list, 2), lists);
 
@@ -359,7 +359,7 @@ public class EasyStreamTest {
 
 	@Test
 	public void testSplitList() {
-		List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
+		final List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
 		List<List<Integer>> lists = EasyStream.of(list).splitList(2).toList();
 		Assert.assertEquals(ListUtil.split(list, 2), lists);
 
@@ -429,7 +429,7 @@ public class EasyStreamTest {
 
 	@Test
 	public void testTransform() {
-		boolean result = EasyStream.of(1, 2, 3)
+		final boolean result = EasyStream.of(1, 2, 3)
 			.transform(EasyStream::toList)
 			.map(List::isEmpty)
 			.orElse(false);