fix comment

hutool-core/src/main/java/cn/hutool/core/annotation/SynthesizedAnnotationSelector.java

@@ -32,6 +32,7 @@ public interface SynthesizedAnnotationSelector {
 	/**
 	 * 比较两个被合成的注解，选择其中的一个并返回
 	 *
+	 * @param <T>           复合注解类型
 	 * @param oldAnnotation 已存在的注解，该参数不允许为空
 	 * @param newAnnotation 新获取的注解，该参数不允许为空
 	 * @return 被合成的注解

hutool-core/src/main/java/cn/hutool/core/annotation/scanner/AbstractTypeAnnotationScanner.java

@@ -219,6 +219,9 @@ public abstract class AbstractTypeAnnotationScanner<T extends AbstractTypeAnnota
 
 	/**
 	 * 当前类是否不需要处理
+	 *
+	 * @param accessedTypes 访问类型
+	 * @param targetClass   目标类型
 	 */
 	protected boolean isNotNeedProcess(Set<Class<?>> accessedTypes, Class<?> targetClass) {
 		return ObjectUtil.isNull(targetClass)
@@ -229,6 +232,9 @@ public abstract class AbstractTypeAnnotationScanner<T extends AbstractTypeAnnota
 
 	/**
 	 * 若{@link #includeInterfaces}为{@code true}，则将目标类的父接口也添加到nextClasses
+	 *
+	 * @param nextClasses 下一个类集合
+	 * @param targetClass 目标类型
 	 */
 	protected void scanInterfaceIfNecessary(List<Class<?>> nextClasses, Class<?> targetClass) {
 		if (includeInterfaces) {
@@ -241,6 +247,9 @@ public abstract class AbstractTypeAnnotationScanner<T extends AbstractTypeAnnota
 
 	/**
 	 * 若{@link #includeSupperClass}为{@code true}，则将目标类的父类也添加到nextClasses
+	 *
+	 * @param nextClassQueue 下一个类队列
+	 * @param targetClass    目标类型
 	 */
 	protected void scanSuperClassIfNecessary(List<Class<?>> nextClassQueue, Class<?> targetClass) {
 		if (includeSupperClass) {
@@ -253,6 +262,8 @@ public abstract class AbstractTypeAnnotationScanner<T extends AbstractTypeAnnota
 
 	/**
 	 * 若存在转换器，则使用转换器对目标类进行转换
+	 *
+	 * @param target 目标类
 	 */
 	protected Class<?> convert(Class<?> target) {
 		if (hasConverters) {

hutool-core/src/main/java/cn/hutool/core/map/ForestMap.java

@@ -66,7 +66,7 @@ public interface ForestMap<K, V> extends Map<K, TreeEntry<K, V>> {
 	 *     <li>若存在父节点或子节点，则将其断开其与父节点或子节点的引用关系；</li>
 	 *     <li>
 	 *         若同时存在父节点或子节点，则会在删除后将让子节点直接成为父节点的子节点，比如：<br>
-	 *         现有引用关系 a -> b -> c，删除 b 后，将有 a -> c
+	 *         现有引用关系 a -&gt; b -&gt; c，删除 b 后，将有 a -&gt; c
 	 *     </li>
 	 * </ul>
 	 *
@@ -87,6 +87,7 @@ public interface ForestMap<K, V> extends Map<K, TreeEntry<K, V>> {
 	/**
 	 * 批量添加节点
 	 *
+	 * @param <C>                集合类型
 	 * @param values             要添加的值
 	 * @param keyGenerator       从值中获取key的方法
 	 * @param parentKeyGenerator 从值中获取父节点key的方法
@@ -102,8 +103,8 @@ public interface ForestMap<K, V> extends Map<K, TreeEntry<K, V>> {
 			final K parentKey = parentKeyGenerator.apply(v);
 
 			// 不忽略keu为null节点
-			boolean hasKey = ObjectUtil.isNotNull(key);
+			final boolean hasKey = ObjectUtil.isNotNull(key);
-			boolean hasParentKey = ObjectUtil.isNotNull(parentKey);
+			final boolean hasParentKey = ObjectUtil.isNotNull(parentKey);
 			if (!ignoreNullNode || (hasKey && hasParentKey)) {
 				linkNodes(parentKey, key);
 				get(key).setValue(v);
@@ -207,7 +208,7 @@ public interface ForestMap<K, V> extends Map<K, TreeEntry<K, V>> {
 
 	/**
 	 * 获取指定节点所在树结构的全部树节点 <br>
-	 * 比如：存在 a -> b -> c 的关系，则输入 a/b/c 都将返回 a, b, c
+	 * 比如：存在 a -&gt; b -&gt; c 的关系，则输入 a/b/c 都将返回 a, b, c
 	 *
 	 * @param key 指定节点的key
 	 * @return 节点
@@ -217,14 +218,14 @@ public interface ForestMap<K, V> extends Map<K, TreeEntry<K, V>> {
 		if (ObjectUtil.isNull(target)) {
 			return Collections.emptySet();
 		}
-		Set<TreeEntry<K, V>> results = CollUtil.newLinkedHashSet(target.getRoot());
+		final Set<TreeEntry<K, V>> results = CollUtil.newLinkedHashSet(target.getRoot());
 		CollUtil.addAll(results, target.getRoot().getChildren().values());
 		return results;
 	}
 
 	/**
 	 * 获取以指定节点作为叶子节点的树结构，然后获取该树结构的根节点 <br>
-	 * 比如：存在 a -> b -> c 的关系，则输入 a/b/c 都将返回 a
+	 * 比如：存在 a -&gt; b -&gt; c 的关系，则输入 a/b/c 都将返回 a
 	 *
 	 * @param key 指定节点的key
 	 * @return 节点
@@ -237,7 +238,7 @@ public interface ForestMap<K, V> extends Map<K, TreeEntry<K, V>> {
 
 	/**
 	 * 获取指定节点的直接父节点 <br>
-	 * 比如：若存在 a -> b -> c 的关系，此时输入 a 将返回 null，输入 b 将返回 a，输入 c 将返回 b
+	 * 比如：若存在 a -&gt; b -&gt; c 的关系，此时输入 a 将返回 null，输入 b 将返回 a，输入 c 将返回 b
 	 *
 	 * @param key 指定节点的key
 	 * @return 节点
@@ -251,7 +252,8 @@ public interface ForestMap<K, V> extends Map<K, TreeEntry<K, V>> {
 	/**
 	 * 获取以指定节点作为叶子节点的树结构，然后获取该树结构中指定节点的指定父节点
 	 *
-	 * @param key 指定父节点的key
+	 * @param key       指定节点的key
+	 * @param parentKey 指定父节点key
 	 * @return 节点
 	 */
 	default TreeEntry<K, V> getParentNode(K key, K parentKey) {
@@ -290,7 +292,7 @@ public interface ForestMap<K, V> extends Map<K, TreeEntry<K, V>> {
 
 	/**
 	 * 获取指定父节点直接关联的子节点 <br>
-	 * 比如：若存在 a -> b -> c 的关系，此时输入 b 将返回 c，输入 a 将返回 b
+	 * 比如：若存在 a -&gt; b -&gt; c 的关系，此时输入 b 将返回 c，输入 a 将返回 b
 	 *
 	 * @param key key
 	 * @return 节点
@@ -304,7 +306,7 @@ public interface ForestMap<K, V> extends Map<K, TreeEntry<K, V>> {
 
 	/**
 	 * 获取指定父节点的全部子节点 <br>
-	 * 比如：若存在 a -> b -> c 的关系，此时输入 b 将返回 c，输入 a 将返回 b，c
+	 * 比如：若存在 a -&gt; b -&gt; c 的关系，此时输入 b 将返回 c，输入 a 将返回 b，c
 	 *
 	 * @param key key
 	 * @return 该节点的全部子节点

hutool-core/src/main/java/cn/hutool/core/map/LinkedForestMap.java

@@ -262,7 +262,8 @@ public class LinkedForestMap<K, V> implements ForestMap<K, V> {
 	 */
 	@Override
 	public void linkNodes(K parentKey, K childKey, BiConsumer<TreeEntry<K, V>, TreeEntry<K, V>> consumer) {
-		consumer = ObjectUtil.defaultIfNull(consumer, (parent, child) -> {});
+		consumer = ObjectUtil.defaultIfNull(consumer, (parent, child) -> {
+		});
 		final TreeEntryNode<K, V> parentNode = nodes.computeIfAbsent(parentKey, t -> new TreeEntryNode<>(null, t));
 		TreeEntryNode<K, V> childNode = nodes.get(childKey);
 
@@ -472,7 +473,8 @@ public class LinkedForestMap<K, V> implements ForestMap<K, V> {
 			if (ObjectUtil.isNotNull(this.root)) {
 				return this.root;
 			} else {
-				this.root = traverseParentNodes(true, p -> {}, p -> !p.hasParent());
+				this.root = traverseParentNodes(true, p -> {
+				}, p -> !p.hasParent());
 			}
 			return this.root;
 		}
@@ -495,7 +497,8 @@ public class LinkedForestMap<K, V> implements ForestMap<K, V> {
 		 */
 		@Override
 		public TreeEntryNode<K, V> getParent(K key) {
-			return traverseParentNodes(false, p -> {}, p -> p.equalsKey(key));
+			return traverseParentNodes(false, p -> {
+			}, p -> p.equalsKey(key));
 		}
 
 		/**
@@ -513,6 +516,7 @@ public class LinkedForestMap<K, V> implements ForestMap<K, V> {
 		 * 指定key与当前节点的key是否相等
 		 *
 		 * @param key 要比较的key
+		 * @return 是否key一致
 		 */
 		public boolean equalsKey(K key) {
 			return ObjectUtil.equal(getKey(), key);
@@ -594,7 +598,7 @@ public class LinkedForestMap<K, V> implements ForestMap<K, V> {
 		 * @param key 子节点
 		 */
 		void removeDeclaredChild(K key) {
-			TreeEntryNode<K, V> child = children.get(key);
+			final TreeEntryNode<K, V> child = children.get(key);
 			if (ObjectUtil.isNull(child)) {
 				return;
 			}
@@ -618,7 +622,8 @@ public class LinkedForestMap<K, V> implements ForestMap<K, V> {
 		 */
 		@Override
 		public TreeEntryNode<K, V> getChild(K key) {
-			return traverseChildNodes(false, (i, c) -> {}, (i, c) -> c.equalsKey(key));
+			return traverseChildNodes(false, (i, c) -> {
+			}, (i, c) -> c.equalsKey(key));
 		}
 
 		/**
@@ -707,17 +712,21 @@ public class LinkedForestMap<K, V> implements ForestMap<K, V> {
 	 */
 	public static class EntryNodeWrapper<K, V, N extends TreeEntry<K, V>> implements Map.Entry<K, TreeEntry<K, V>> {
 		private final N entryNode;
+
 		EntryNodeWrapper(N entryNode) {
 			this.entryNode = entryNode;
 		}
+
 		@Override
 		public K getKey() {
 			return entryNode.getKey();
 		}
+
 		@Override
 		public TreeEntry<K, V> getValue() {
 			return entryNode;
 		}
+
 		@Override
 		public TreeEntry<K, V> setValue(TreeEntry<K, V> value) {
 			throw new UnsupportedOperationException();