diff --git a/hutool-core/src/main/java/org/dromara/hutool/core/stream/CollectorUtil.java b/hutool-core/src/main/java/org/dromara/hutool/core/stream/CollectorUtil.java
index 4c62590d2..9762b358c 100644
--- a/hutool-core/src/main/java/org/dromara/hutool/core/stream/CollectorUtil.java
+++ b/hutool-core/src/main/java/org/dromara/hutool/core/stream/CollectorUtil.java
@@ -472,132 +472,132 @@ public class CollectorUtil {
 	}
 
 	/**
-	 * 将一个Collection<T>两个属性分流至两个ArrayList,并使用Pair收集。
+	 * 将一个{@code Collection<T>}两个属性分流至两个ArrayList,并使用Pair收集。
 	 *
-	 * @param lMapper    左属性收集方法
-	 * @param rMapper    右属性收集方法
-	 * @param <T>        元素类型
-	 * @param <L>        左属性类型
-	 * @param <R>        右属性类型
-	 * @return Pair<List<L>,List<R>> Pair收集的两个List
+	 * @param lMapper 左属性收集方法
+	 * @param rMapper 右属性收集方法
+	 * @param <T>     元素类型
+	 * @param <L>     左属性类型
+	 * @param <R>     右属性类型
+	 * @return {@code Pair<List<L>,List<R>>} Pair收集的两个List
 	 * @author Tanglt
 	 */
-	public static <T, L, R> Collector<T, Pair<List<L>,List<R>>, Pair<List<L>,List<R>>> toPairList(Function<T, L> lMapper,
-																								  Function<T, R> rMapper) {
-		return toPairCollection(lMapper,rMapper,ArrayList::new,ArrayList::new);
+	public static <T, L, R> Collector<T, Pair<List<L>, List<R>>, Pair<List<L>, List<R>>> toPairList(final Function<T, L> lMapper,
+																									final Function<T, R> rMapper) {
+		return toPairCollection(lMapper, rMapper, ArrayList::new, ArrayList::new);
 
 	}
 
 	/**
-	 * 将一个Collection<T>两个属性分流至两个Collection,并使用Pair收集。需要指定Collection类型
+	 * 将一个{@code Collection<T>}两个属性分流至两个Collection,并使用Pair收集。需要指定Collection类型
 	 *
-	 * @param lMapper          左属性收集方法
-	 * @param rMapper          右属性收集方法
-	 * @param newCollectionL   左属性Collection创建方法
-	 * @param newCollectionR   右属性Collection创建方法
-	 * @param <T>              元素类型
-	 * @param <L>              左属性类型
-	 * @param <R>              右属性类型
-	 * @param <LC>             左分流Collection类型
-	 * @param <RC>             右分流Collection类型
-	 * @return Pair<C<L>,C<R>> Pair收集的两个List
+	 * @param lMapper        左属性收集方法
+	 * @param rMapper        右属性收集方法
+	 * @param newCollectionL 左属性Collection创建方法
+	 * @param newCollectionR 右属性Collection创建方法
+	 * @param <T>            元素类型
+	 * @param <L>            左属性类型
+	 * @param <R>            右属性类型
+	 * @param <LC>           左分流Collection类型
+	 * @param <RC>           右分流Collection类型
+	 * @return {@code Pair<C<L>,C<R>>} Pair收集的两个List
 	 * @author Tanglt
 	 */
-	public static <T, L, R,LC extends Collection<L>,RC extends Collection<R>>
-	Collector<T, Pair<LC, RC>, Pair<LC, RC>> toPairCollection(Function<T, L> lMapper,
-														Function<T, R> rMapper,
-														Supplier<LC> newCollectionL,
-														Supplier<RC> newCollectionR) {
+	public static <T, L, R, LC extends Collection<L>, RC extends Collection<R>>
+	Collector<T, Pair<LC, RC>, Pair<LC, RC>> toPairCollection(final Function<T, L> lMapper,
+															  final Function<T, R> rMapper,
+															  final Supplier<LC> newCollectionL,
+															  final Supplier<RC> newCollectionR) {
 		return new SimpleCollector<>(() -> Pair.of(newCollectionL.get(), newCollectionR.get()),
-				(listPair, element) -> {
-					L lValue = lMapper.apply(element);
-					if (lValue != null) {
-						listPair.getLeft().add(lValue);
-					}
-					R rValue = rMapper.apply(element);
-					if (rValue != null) {
-						listPair.getRight().add(rValue);
-					}
-				},
-				(listPair1, listPair2) -> {
-					listPair1.getLeft().addAll(listPair2.getLeft());
-					listPair1.getRight().addAll(listPair2.getRight());
-					return listPair1;
-				},
-				CH_ID);
+			(listPair, element) -> {
+				final L lValue = lMapper.apply(element);
+				if (lValue != null) {
+					listPair.getLeft().add(lValue);
+				}
+				final R rValue = rMapper.apply(element);
+				if (rValue != null) {
+					listPair.getRight().add(rValue);
+				}
+			},
+			(listPair1, listPair2) -> {
+				listPair1.getLeft().addAll(listPair2.getLeft());
+				listPair1.getRight().addAll(listPair2.getRight());
+				return listPair1;
+			},
+			CH_ID);
 	}
 
 	/**
-	 * 将一个Collection<T>三个属性分流至三个ArrayList,并使用Triple收集。
+	 * 将一个{@code Collection<T>}三个属性分流至三个ArrayList,并使用Triple收集。
 	 *
-	 * @param lMapper    左属性收集方法
-	 * @param mMapper    中属性收集方法
-	 * @param rMapper    右属性收集方法
-	 * @param <T>        元素类型
-	 * @param <L>        左属性类型
-	 * @param <M>        中属性类型
-	 * @param <R>        右属性类型
-	 * @return Triple<List<L>,List<M>,List<R>> Triple收集的三个List
+	 * @param lMapper 左属性收集方法
+	 * @param mMapper 中属性收集方法
+	 * @param rMapper 右属性收集方法
+	 * @param <T>     元素类型
+	 * @param <L>     左属性类型
+	 * @param <M>     中属性类型
+	 * @param <R>     右属性类型
+	 * @return {@code Triple<List<L>,List<M>,List<R>>} Triple收集的三个List
 	 * @author Tanglt
 	 */
 	public static <T, L, M, R>
-	Collector<T, Triple<List<L>, List<M>, List<R>>, Triple<List<L>, List<M>, List<R>>> toTripleList(Function<T, L> lMapper,
-																									Function<T, M> mMapper,
-																									Function<T, R> rMapper) {
+	Collector<T, Triple<List<L>, List<M>, List<R>>, Triple<List<L>, List<M>, List<R>>> toTripleList(final Function<T, L> lMapper,
+																									final Function<T, M> mMapper,
+																									final Function<T, R> rMapper) {
 		return toTripleCollection(lMapper, mMapper, rMapper, ArrayList::new, ArrayList::new, ArrayList::new);
 	}
 
 	/**
-	 * 将一个Collection<T>两个属性分流至两个Collection,并使用Pair收集。需要指定Collection类型
+	 * 将一个{@code Collection<T>}两个属性分流至两个Collection,并使用Pair收集。需要指定Collection类型
 	 *
-	 * @param lMapper          左属性收集方法
-	 * @param mMapper          中属性收集方法
-	 * @param rMapper          右属性收集方法
-	 * @param newCollectionL   左属性Collection创建方法
-	 * @param newCollectionM   中属性Collection创建方法
-	 * @param newCollectionR   右属性Collection创建方法
-	 * @param <T>              元素类型
-	 * @param <L>              左属性类型
-	 * @param <M>              中属性类型
-	 * @param <R>              右属性类型
-	 * @param <LC>             左分流Collection类型
-	 * @param <MC>             中分流Collection类型
-	 * @param <RC>             右分流Collection类型
-	 * @return Triple<LC<L>,MC<M>,RC<R>> Triple收集的三个List
+	 * @param lMapper        左属性收集方法
+	 * @param mMapper        中属性收集方法
+	 * @param rMapper        右属性收集方法
+	 * @param newCollectionL 左属性Collection创建方法
+	 * @param newCollectionM 中属性Collection创建方法
+	 * @param newCollectionR 右属性Collection创建方法
+	 * @param <T>            元素类型
+	 * @param <L>            左属性类型
+	 * @param <M>            中属性类型
+	 * @param <R>            右属性类型
+	 * @param <LC>           左分流Collection类型
+	 * @param <MC>           中分流Collection类型
+	 * @param <RC>           右分流Collection类型
+	 * @return {@code Triple<LC<L>,MC<M>,RC<R>>} Triple收集的三个List
 	 * @author Tanglt
 	 */
-	public static <T, L,  M,R,
-			LC extends Collection<L>,
-			MC extends Collection<M>,
-			RC extends Collection<R>>
-	Collector<T, Triple<LC,MC,RC>,Triple<LC,MC,RC>> toTripleCollection(Function<T, L> lMapper,
-									  Function<T, M> mMapper,
-									  Function<T, R> rMapper,
-									  Supplier<LC> newCollectionL,
-									  Supplier<MC> newCollectionM,
-									  Supplier<RC> newCollectionR){
+	public static <T, L, M, R,
+		LC extends Collection<L>,
+		MC extends Collection<M>,
+		RC extends Collection<R>>
+	Collector<T, Triple<LC, MC, RC>, Triple<LC, MC, RC>> toTripleCollection(final Function<T, L> lMapper,
+																			final Function<T, M> mMapper,
+																			final Function<T, R> rMapper,
+																			final Supplier<LC> newCollectionL,
+																			final Supplier<MC> newCollectionM,
+																			final Supplier<RC> newCollectionR) {
 		return new SimpleCollector<>(
-				() -> Triple.of(newCollectionL.get(),newCollectionM.get(), newCollectionR.get()),
-				(listTriple, element) -> {
-					L lValue = lMapper.apply(element);
-					if (lValue != null) {
-						listTriple.getLeft().add(lValue);
-					}
-					M mValue = mMapper.apply(element);
-					if (mValue != null) {
-						listTriple.getMiddle().add(mValue);
-					}
-					R rValue = rMapper.apply(element);
-					if (rValue != null) {
-						listTriple.getRight().add(rValue);
-					}
-				},
-				(listTriple1, listTriple2) -> {
-					listTriple1.getLeft().addAll(listTriple2.getLeft());
-					listTriple1.getRight().addAll(listTriple2.getRight());
-					return listTriple1;
-				},
-				CH_ID);
+			() -> Triple.of(newCollectionL.get(), newCollectionM.get(), newCollectionR.get()),
+			(listTriple, element) -> {
+				final L lValue = lMapper.apply(element);
+				if (lValue != null) {
+					listTriple.getLeft().add(lValue);
+				}
+				final M mValue = mMapper.apply(element);
+				if (mValue != null) {
+					listTriple.getMiddle().add(mValue);
+				}
+				final R rValue = rMapper.apply(element);
+				if (rValue != null) {
+					listTriple.getRight().add(rValue);
+				}
+			},
+			(listTriple1, listTriple2) -> {
+				listTriple1.getLeft().addAll(listTriple2.getLeft());
+				listTriple1.getRight().addAll(listTriple2.getRight());
+				return listTriple1;
+			},
+			CH_ID);
 	}
 
 }
diff --git a/hutool-core/src/test/java/org/dromara/hutool/core/stream/CollectorUtilTest.java b/hutool-core/src/test/java/org/dromara/hutool/core/stream/CollectorUtilTest.java
index 4eab5d0d8..4b47e2075 100644
--- a/hutool-core/src/test/java/org/dromara/hutool/core/stream/CollectorUtilTest.java
+++ b/hutool-core/src/test/java/org/dromara/hutool/core/stream/CollectorUtilTest.java
@@ -141,13 +141,13 @@ public class CollectorUtilTest {
 	@Test
 	public void testToPairList() {
 		final List<Pair<Integer,String>> list = Arrays.asList(Pair.of(1,"one"), Pair.of(2,"two"));
-		Pair<List<Integer>, List<String>> pairList = list.stream()
+		final Pair<List<Integer>, List<String>> pairList = list.stream()
 				.collect(CollectorUtil.toPairList(Pair::getLeft, Pair::getRight));
 
 		Assertions.assertEquals(pairList.getLeft().size(),list.size());
 		Assertions.assertEquals(pairList.getRight().size(),list.size());
 
-		Pair<HashSet<Integer>, ArrayList<String>> pairMixed = list.stream()
+		final Pair<HashSet<Integer>, ArrayList<String>> pairMixed = list.stream()
 				.collect(CollectorUtil.toPairCollection(Pair::getLeft, Pair::getRight, HashSet::new, ArrayList::new));
 
 		Assertions.assertEquals(pairMixed.getLeft().size(),list.size());
@@ -160,14 +160,14 @@ public class CollectorUtilTest {
 	public void testToTripleList() {
 		final List<Triple<Integer,Long,String>> list
 				= Arrays.asList(Triple.of(1,1L,"one"), Triple.of(2,2L,"two"));
-		Triple<List<Integer>, List<Long>, List<String>> tripleList = list.stream()
+		final Triple<List<Integer>, List<Long>, List<String>> tripleList = list.stream()
 				.collect(CollectorUtil.toTripleList(Triple::getLeft, Triple::getMiddle, Triple::getRight));
 
 		Assertions.assertEquals(tripleList.getLeft().size(),list.size());
 		Assertions.assertEquals(tripleList.getMiddle().size(),list.size());
 		Assertions.assertEquals(tripleList.getRight().size(),list.size());
 
-		Triple<HashSet<Integer>, HashSet<Long>, ArrayList<String>> tripleMixed = list.stream()
+		final Triple<HashSet<Integer>, HashSet<Long>, ArrayList<String>> tripleMixed = list.stream()
 				.collect(CollectorUtil.toTripleCollection(Triple::getLeft, Triple::getMiddle, Triple::getRight, HashSet::new, HashSet::new, ArrayList::new));
 
 		Assertions.assertEquals(tripleMixed.getLeft().size(),list.size());