diff --git a/hutool-core/src/main/java/cn/hutool/core/stream/CollectorUtil.java b/hutool-core/src/main/java/cn/hutool/core/stream/CollectorUtil.java
index 1dcc72096..ecbfab5a7 100644
--- a/hutool-core/src/main/java/cn/hutool/core/stream/CollectorUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/stream/CollectorUtil.java
@@ -277,7 +277,7 @@ public class CollectorUtil {
 	 * @since 6.0.0
 	 */
 	public static <T, K> Collector<T, List<T>, EntryStream<K, T>> toEntryStream(
-			Function<? super T, ? extends K> keyMapper) {
+			final Function<? super T, ? extends K> keyMapper) {
 		return toEntryStream(keyMapper, Function.identity());
 	}
 
diff --git a/hutool-core/src/main/java/cn/hutool/core/stream/EntryStream.java b/hutool-core/src/main/java/cn/hutool/core/stream/EntryStream.java
index dff2c8801..f712f40fd 100644
--- a/hutool-core/src/main/java/cn/hutool/core/stream/EntryStream.java
+++ b/hutool-core/src/main/java/cn/hutool/core/stream/EntryStream.java
@@ -38,7 +38,7 @@ public class EntryStream<K, V> extends AbstractEnhancedWrappedStream<Map.Entry<K
 	 * @param <V>    值类型
 	 * @param keys   键集合
 	 * @param values 值集合
-	 * @return {@link EntryStream}实例
+	 * @return {@code EntryStream}实例
 	 */
 	public static <K, V> EntryStream<K, V> merge(final Iterable<K> keys, final Iterable<V> values) {
 		final boolean hasKeys = ObjUtil.isNotNull(keys);
@@ -75,7 +75,7 @@ public class EntryStream<K, V> extends AbstractEnhancedWrappedStream<Map.Entry<K
 	 * @param map 集合
 	 * @param <K> 键类型
 	 * @param <V> 值类型
-	 * @return {@link EntryStream}实例
+	 * @return {@code EntryStream}实例
 	 */
 	public static <K, V> EntryStream<K, V> of(final Map<K, V> map) {
 		return ObjUtil.isNull(map) ?
@@ -90,7 +90,7 @@ public class EntryStream<K, V> extends AbstractEnhancedWrappedStream<Map.Entry<K
 	 * @param entries {@link Iterable}实例
 	 * @param <K>     键类型
 	 * @param <V>     值类型
-	 * @return {@link EntryStream}实例
+	 * @return {@code EntryStream}实例
 	 */
 	public static <K, V> EntryStream<K, V> of(final Iterable<? extends Map.Entry<K, V>> entries) {
 		return ObjUtil.isNull(entries) ?
@@ -106,10 +106,10 @@ public class EntryStream<K, V> extends AbstractEnhancedWrappedStream<Map.Entry<K
 	 * @param <T>         元素类型
 	 * @param <K>         键类型
 	 * @param <V>         值类型
-	 * @return {@link EntryStream}实例
+	 * @return {@code EntryStream}实例
 	 */
 	public static <T, K, V> EntryStream<K, V> of(
-			final Iterable<T> source, Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends V> valueMapper) {
+			final Iterable<T> source, final Function<? super T, ? extends K> keyMapper, final Function<? super T, ? extends V> valueMapper) {
 		Objects.requireNonNull(keyMapper);
 		Objects.requireNonNull(valueMapper);
 		if (ObjUtil.isNull(source)) {
@@ -127,9 +127,9 @@ public class EntryStream<K, V> extends AbstractEnhancedWrappedStream<Map.Entry<K
 	 * @param stream 流
 	 * @param <K>    键类型
 	 * @param <V>    值类型
-	 * @return {@link EntryStream}实例
+	 * @return {@code EntryStream}实例
 	 */
-	public static <K, V> EntryStream<K, V> of(Stream<? extends Map.Entry<K, V>> stream) {
+	public static <K, V> EntryStream<K, V> of(final Stream<? extends Map.Entry<K, V>> stream) {
 		return ObjUtil.isNull(stream) ?
 				empty() : new EntryStream<>(stream.map(EntryStream::ofEntry));
 	}
@@ -139,7 +139,7 @@ public class EntryStream<K, V> extends AbstractEnhancedWrappedStream<Map.Entry<K
 	 *
 	 * @param <K> 键类型
 	 * @param <V> 值类型
-	 * @return {@link EntryStream}实例
+	 * @return {@code EntryStream}实例
 	 */
 	public static <K, V> EntryStream<K, V> empty() {
 		return new EntryStream<>(Stream.empty());
@@ -157,7 +157,7 @@ public class EntryStream<K, V> extends AbstractEnhancedWrappedStream<Map.Entry<K
 	/**
 	 * 根据键去重，默认丢弃靠后的
 	 *
-	 * @return {@link EntryStream}实例
+	 * @return {@code EntryStream}实例
 	 */
 	public EntryStream<K, V> distinctByKey() {
 		// FIXME fix happen NPE when has null key
@@ -175,7 +175,7 @@ public class EntryStream<K, V> extends AbstractEnhancedWrappedStream<Map.Entry<K
 	/**
 	 * 根据值去重，默认丢弃靠后的
 	 *
-	 * @return {@link EntryStream}实例
+	 * @return {@code EntryStream}实例
 	 */
 	public EntryStream<K, V> distinctByValue() {
 		// FIXME fix happen NPE when has null value
@@ -194,7 +194,7 @@ public class EntryStream<K, V> extends AbstractEnhancedWrappedStream<Map.Entry<K
 	 * 根据键和值过滤键值对
 	 *
 	 * @param filter 判断条件
-	 * @return {@link EntryStream}实例
+	 * @return {@code EntryStream}实例
 	 */
 	public EntryStream<K, V> filter(final BiPredicate<? super K, ? super V> filter) {
 		Objects.requireNonNull(filter);
@@ -205,7 +205,7 @@ public class EntryStream<K, V> extends AbstractEnhancedWrappedStream<Map.Entry<K
 	 * 根据键过滤键值对
 	 *
 	 * @param filter 判断条件
-	 * @return {@link EntryStream}实例
+	 * @return {@code EntryStream}实例
 	 */
 	public EntryStream<K, V> filterByKey(final Predicate<? super K> filter) {
 		Objects.requireNonNull(filter);
@@ -216,7 +216,7 @@ public class EntryStream<K, V> extends AbstractEnhancedWrappedStream<Map.Entry<K
 	 * 根据值过滤键值对
 	 *
 	 * @param filter 判断条件
-	 * @return {@link EntryStream}实例
+	 * @return {@code EntryStream}实例
 	 */
 	public EntryStream<K, V> filterByValue(final Predicate<? super V> filter) {
 		Objects.requireNonNull(filter);
@@ -226,7 +226,7 @@ public class EntryStream<K, V> extends AbstractEnhancedWrappedStream<Map.Entry<K
 	/**
 	 * 过滤流中键值对本身、键值对中的值或键为{@code null}的元素
 	 *
-	 * @return {@link EntryStream}实例
+	 * @return {@code EntryStream}实例
 	 */
 	public EntryStream<K, V> nonNullKeyValue() {
 		return super.filter(e -> ObjUtil.isNotNull(e) && ObjUtil.isNotNull(e.getKey()) && ObjUtil.isNotNull(e.getValue()));
@@ -235,7 +235,7 @@ public class EntryStream<K, V> extends AbstractEnhancedWrappedStream<Map.Entry<K
 	/**
 	 * 过滤流中键值对本身，或键值对的键为{@code null}的元素
 	 *
-	 * @return {@link EntryStream}实例
+	 * @return {@code EntryStream}实例
 	 */
 	public EntryStream<K, V> nonNullKey() {
 		return super.filter(e -> ObjUtil.isNotNull(e) && ObjUtil.isNotNull(e.getKey()));
@@ -244,7 +244,7 @@ public class EntryStream<K, V> extends AbstractEnhancedWrappedStream<Map.Entry<K
 	/**
 	 * 过滤流中键值对本身，或键值对的值为{@code null}的元素
 	 *
-	 * @return {@link EntryStream}实例
+	 * @return {@code EntryStream}实例
 	 */
 	public EntryStream<K, V> nonNullValue() {
 		return super.filter(e -> ObjUtil.isNotNull(e) && ObjUtil.isNotNull(e.getValue()));
@@ -254,7 +254,7 @@ public class EntryStream<K, V> extends AbstractEnhancedWrappedStream<Map.Entry<K
 	 * 检查键
 	 *
 	 * @param consumer 操作
-	 * @return {@link EntryStream}实例
+	 * @return {@code EntryStream}实例
 	 */
 	public EntryStream<K, V> peekKey(final Consumer<? super K> consumer) {
 		Objects.requireNonNull(consumer);
@@ -265,7 +265,7 @@ public class EntryStream<K, V> extends AbstractEnhancedWrappedStream<Map.Entry<K
 	 * 检查值
 	 *
 	 * @param consumer 操作
-	 * @return {@link EntryStream}实例
+	 * @return {@code EntryStream}实例
 	 */
 	public EntryStream<K, V> peekValue(final Consumer<? super V> consumer) {
 		Objects.requireNonNull(consumer);
@@ -276,7 +276,7 @@ public class EntryStream<K, V> extends AbstractEnhancedWrappedStream<Map.Entry<K
 	 * 根据键排序
 	 *
 	 * @param comparator 排序器
-	 * @return {@link EntryStream}实例
+	 * @return {@code EntryStream}实例
 	 */
 	public EntryStream<K, V> sortByKey(final Comparator<? super K> comparator) {
 		Objects.requireNonNull(comparator);
@@ -287,7 +287,7 @@ public class EntryStream<K, V> extends AbstractEnhancedWrappedStream<Map.Entry<K
 	 * 根据值排序
 	 *
 	 * @param comparator 排序器
-	 * @return {@link EntryStream}实例
+	 * @return {@code EntryStream}实例
 	 */
 	public EntryStream<K, V> sortByValue(final Comparator<? super V> comparator) {
 		Objects.requireNonNull(comparator);
@@ -301,7 +301,7 @@ public class EntryStream<K, V> extends AbstractEnhancedWrappedStream<Map.Entry<K
 	 *
 	 * @param key   键
 	 * @param value 值
-	 * @return {@link EntryStream}实例
+	 * @return {@code EntryStream}实例
 	 */
 	public EntryStream<K, V> push(final K key, final V value) {
 		return wrap(Stream.concat(stream, Stream.of(ofEntry(key, value))));
@@ -312,7 +312,7 @@ public class EntryStream<K, V> extends AbstractEnhancedWrappedStream<Map.Entry<K
 	 *
 	 * @param key   键
 	 * @param value 值
-	 * @return {@link EntryStream}实例
+	 * @return {@code EntryStream}实例
 	 */
 	public EntryStream<K, V> unshift(final K key, final V value) {
 		return wrap(Stream.concat(Stream.of(ofEntry(key, value)), stream));
@@ -322,7 +322,7 @@ public class EntryStream<K, V> extends AbstractEnhancedWrappedStream<Map.Entry<K
 	 * 将输入元素转为流，返回一个前半段为当前流，后半段为新流的新{@link EasyStream}实例
 	 *
 	 * @param entries 键值对
-	 * @return {@link EntryStream}实例
+	 * @return {@code EntryStream}实例
 	 */
 	@Override
 	public EntryStream<K, V> append(final Iterable<? extends Map.Entry<K, V>> entries) {
@@ -338,7 +338,7 @@ public class EntryStream<K, V> extends AbstractEnhancedWrappedStream<Map.Entry<K
 	 * 将输入元素转为流，返回一个前半段为新流，后半段为当前流的新{@link EasyStream}实例
 	 *
 	 * @param entries 键值对
-	 * @return {@link EntryStream}实例
+	 * @return {@code EntryStream}实例
 	 */
 	@Override
 	public EntryStream<K, V> prepend(final Iterable<? extends Map.Entry<K, V>> entries) {
@@ -373,7 +373,7 @@ public class EntryStream<K, V> extends AbstractEnhancedWrappedStream<Map.Entry<K
 	 *
 	 * @param mapper 映射方法
 	 * @param <N>    新的键类型
-	 * @return {@link EntryStream}实例
+	 * @return {@code EntryStream}实例
 	 */
 	public <N> EntryStream<N, V> mapKeys(final Function<? super K, ? extends N> mapper) {
 		Objects.requireNonNull(mapper);
@@ -387,7 +387,7 @@ public class EntryStream<K, V> extends AbstractEnhancedWrappedStream<Map.Entry<K
 	 *
 	 * @param mapper 映射方法
 	 * @param <N>    新的值类型
-	 * @return {@link EntryStream}实例
+	 * @return {@code EntryStream}实例
 	 */
 	public <N> EntryStream<K, N> mapValues(final Function<? super V, ? extends N> mapper) {
 		Objects.requireNonNull(mapper);
@@ -442,7 +442,7 @@ public class EntryStream<K, V> extends AbstractEnhancedWrappedStream<Map.Entry<K
 
 	/**
 	 * <p>将原有流的键执行mapper操作映射为流，流中的所有所有元素仍然对应原本的值，
-	 * 然后再返回由这些流中所有元素组成的流新{@link EntryStream}串行流。<br>
+	 * 然后再返回由这些流中所有元素组成的流新{@code EntryStream}串行流。<br>
 	 * 效果类似：
 	 * <pre>{@code
 	 * // unwrap = [{a = 1}, {b = 2}, {c = 3}]
@@ -466,7 +466,7 @@ public class EntryStream<K, V> extends AbstractEnhancedWrappedStream<Map.Entry<K
 
 	/**
 	 * <p>将原有流的值执行mapper操作映射为流，流中的所有所有元素仍然对应原本的键，
-	 * 然后再返回由这些流中所有元素组成的流新{@link EntryStream}串行流。<br>
+	 * 然后再返回由这些流中所有元素组成的流新{@code EntryStream}串行流。<br>
 	 * 效果类似：
 	 * <pre>{@code
 	 * // unwrap = [{a = 1}, {b = 2}, {c = 3}]
@@ -664,7 +664,7 @@ public class EntryStream<K, V> extends AbstractEnhancedWrappedStream<Map.Entry<K
 	/**
 	 * 将键值对翻转
 	 *
-	 * @return {@link EntryStream}实例
+	 * @return {@code EntryStream}实例
 	 */
 	public EntryStream<V, K> inverse() {
 		return new EntryStream<>(
@@ -760,7 +760,9 @@ public class EntryStream<K, V> extends AbstractEnhancedWrappedStream<Map.Entry<K
 	 * key重复时直接抛出异常
 	 */
 	private static <T> BinaryOperator<T> throwingMerger() {
-		return (u, v) -> {throw new IllegalStateException(String.format("Duplicate key %s", u));};
+		return (u, v) -> {
+			throw new IllegalStateException(String.format("Duplicate key %s", u));
+		};
 	}
 
 }
diff --git a/hutool-core/src/main/java/cn/hutool/core/stream/TransformableWrappedStream.java b/hutool-core/src/main/java/cn/hutool/core/stream/TransformableWrappedStream.java
index d209d63dc..3272b9bd0 100644
--- a/hutool-core/src/main/java/cn/hutool/core/stream/TransformableWrappedStream.java
+++ b/hutool-core/src/main/java/cn/hutool/core/stream/TransformableWrappedStream.java
@@ -51,8 +51,8 @@ public interface TransformableWrappedStream<T, S extends TransformableWrappedStr
 			final Iterable<U> other,
 			final BiFunction<? super T, ? super U, ? extends R> zipper) {
 		Objects.requireNonNull(zipper);
-		Map<Integer, T> idxIdentityMap = mapIdx((e, idx) -> MapUtil.entry(idx, e)).collect(CollectorUtil.entryToMap());
-		Map<Integer, U> idxOtherMap = EasyStream.of(other).mapIdx((e, idx) -> MapUtil.entry(idx, e)).collect(CollectorUtil.entryToMap());
+		final Map<Integer, T> idxIdentityMap = mapIdx((e, idx) -> MapUtil.entry(idx, e)).collect(CollectorUtil.entryToMap());
+		final Map<Integer, U> idxOtherMap = EasyStream.of(other).mapIdx((e, idx) -> MapUtil.entry(idx, e)).collect(CollectorUtil.entryToMap());
 		if (idxIdentityMap.size() <= idxOtherMap.size()) {
 			return EasyStream.of(idxIdentityMap.keySet(), isParallel()).map(k -> zipper.apply(idxIdentityMap.get(k), idxOtherMap.get(k)));
 		}
diff --git a/hutool-core/src/main/java/cn/hutool/core/stream/package-info.java b/hutool-core/src/main/java/cn/hutool/core/stream/package-info.java
index 155cf24db..dadfa3d59 100644
--- a/hutool-core/src/main/java/cn/hutool/core/stream/package-info.java
+++ b/hutool-core/src/main/java/cn/hutool/core/stream/package-info.java
@@ -1,7 +1,6 @@
 /**
  * Java8的stream相关封装
  *
- * @author looly
- *
+ * @author Looly, VampireAchao, huangchengxing, emptypoint
  */
 package cn.hutool.core.stream;
diff --git a/hutool-core/src/main/java/cn/hutool/core/stream/spliterators/DropWhileSpliterator.java b/hutool-core/src/main/java/cn/hutool/core/stream/spliterators/DropWhileSpliterator.java
index 4bb620670..da50ee216 100644
--- a/hutool-core/src/main/java/cn/hutool/core/stream/spliterators/DropWhileSpliterator.java
+++ b/hutool-core/src/main/java/cn/hutool/core/stream/spliterators/DropWhileSpliterator.java
@@ -14,7 +14,7 @@ import java.util.function.Predicate;
  */
 public class DropWhileSpliterator<T> implements Spliterator<T> {
 
-	public static <T> DropWhileSpliterator<T> create(Spliterator<T> source, Predicate<? super T> predicate) {
+	public static <T> DropWhileSpliterator<T> create(final Spliterator<T> source, final Predicate<? super T> predicate) {
 		return new DropWhileSpliterator<>(source, predicate);
 	}
 
@@ -22,13 +22,13 @@ public class DropWhileSpliterator<T> implements Spliterator<T> {
 	private final Predicate<? super T> predicate;
 	private boolean isFound = false;
 
-	private DropWhileSpliterator(Spliterator<T> source, Predicate<? super T> predicate) {
+	private DropWhileSpliterator(final Spliterator<T> source, final Predicate<? super T> predicate) {
 		this.source = source;
 		this.predicate = predicate;
 	}
 
 	@Override
-	public boolean tryAdvance(Consumer<? super T> action) {
+	public boolean tryAdvance(final Consumer<? super T> action) {
 		boolean hasNext = true;
 		// 如果 还没找到 并且 流中还有元素 继续找
 		while (!isFound && hasNext) {
diff --git a/hutool-core/src/main/java/cn/hutool/core/stream/spliterators/IterateSpliterator.java b/hutool-core/src/main/java/cn/hutool/core/stream/spliterators/IterateSpliterator.java
index edf2170f5..9a2d37642 100644
--- a/hutool-core/src/main/java/cn/hutool/core/stream/spliterators/IterateSpliterator.java
+++ b/hutool-core/src/main/java/cn/hutool/core/stream/spliterators/IterateSpliterator.java
@@ -25,24 +25,24 @@ public class IterateSpliterator<T> extends Spliterators.AbstractSpliterator<T> {
 	 * Creates a spliterator reporting the given estimated size and
 	 * additionalCharacteristics.
 	 */
-	IterateSpliterator(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next) {
+	IterateSpliterator(final T seed, final Predicate<? super T> hasNext, final UnaryOperator<T> next) {
 		super(Long.MAX_VALUE, Spliterator.ORDERED | Spliterator.IMMUTABLE);
 		this.seed = seed;
 		this.hasNext = hasNext;
 		this.next = next;
 	}
 
-	public static <T> IterateSpliterator<T> create(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next) {
+	public static <T> IterateSpliterator<T> create(final T seed, final Predicate<? super T> hasNext, final UnaryOperator<T> next) {
 		return new IterateSpliterator<>(seed, hasNext, next);
 	}
 
 	@Override
-	public boolean tryAdvance(Consumer<? super T> action) {
+	public boolean tryAdvance(final Consumer<? super T> action) {
 		Objects.requireNonNull(action);
 		if (finished) {
 			return false;
 		}
-		T t;
+		final T t;
 		if (started) {
 			t = next.apply(prev);
 		} else {
@@ -60,7 +60,7 @@ public class IterateSpliterator<T> extends Spliterators.AbstractSpliterator<T> {
 	}
 
 	@Override
-	public void forEachRemaining(Consumer<? super T> action) {
+	public void forEachRemaining(final Consumer<? super T> action) {
 		Objects.requireNonNull(action);
 		if (finished) {
 			return;
diff --git a/hutool-core/src/main/java/cn/hutool/core/stream/spliterators/TakeWhileSpliterator.java b/hutool-core/src/main/java/cn/hutool/core/stream/spliterators/TakeWhileSpliterator.java
index 318e33351..3313cd285 100644
--- a/hutool-core/src/main/java/cn/hutool/core/stream/spliterators/TakeWhileSpliterator.java
+++ b/hutool-core/src/main/java/cn/hutool/core/stream/spliterators/TakeWhileSpliterator.java
@@ -14,7 +14,7 @@ import java.util.function.Predicate;
  */
 public class TakeWhileSpliterator<T> implements Spliterator<T> {
 
-	public static <T> TakeWhileSpliterator<T> create(Spliterator<T> source, Predicate<? super T> predicate) {
+	public static <T> TakeWhileSpliterator<T> create(final Spliterator<T> source, final Predicate<? super T> predicate) {
 		return new TakeWhileSpliterator<>(source, predicate);
 	}
 
@@ -22,13 +22,13 @@ public class TakeWhileSpliterator<T> implements Spliterator<T> {
 	private final Predicate<? super T> predicate;
 	private boolean isContinue = true;
 
-	TakeWhileSpliterator(Spliterator<T> source, Predicate<? super T> predicate) {
+	TakeWhileSpliterator(final Spliterator<T> source, final Predicate<? super T> predicate) {
 		this.source = source;
 		this.predicate = predicate;
 	}
 
 	@Override
-	public boolean tryAdvance(Consumer<? super T> action) {
+	public boolean tryAdvance(final Consumer<? super T> action) {
 		boolean hasNext = true;
 		// 如果 还可以继续 并且 流中还有元素 则继续遍历
 		while (isContinue && hasNext) {