From e9cf532af0b31f09b5cca719c5df90eca28a1c65 Mon Sep 17 00:00:00 2001
From: Looly <loolly@gmail.com>
Date: Sat, 18 Jun 2022 23:03:06 +0800
Subject: [PATCH] fix code

---
 .../java/cn/hutool/core/bean/BeanUtil.java    | 12 +--
 .../hutool/core/bean/copier/CopyOptions.java  |  8 +-
 .../hutool/core/collection/iter/IterUtil.java | 21 +++--
 .../cn/hutool/core/compress/ZipReader.java    |  8 +-
 .../cn/hutool/core/io/watch/WatchServer.java  | 12 +--
 .../java/cn/hutool/core/lang/func/Editor.java | 24 ------
 .../java/cn/hutool/core/lang/func/Filter.java | 17 ----
 .../cn/hutool/core/lang/func/LambdaInfo.java  | 14 ++--
 .../cn/hutool/core/lang/func/Matcher.java     | 18 -----
 .../cn/hutool/core/lang/func/Replacer.java    | 22 -----
 .../main/java/cn/hutool/core/map/MapUtil.java | 22 ++---
 .../main/java/cn/hutool/core/net/NetUtil.java | 12 +--
 .../cn/hutool/core/reflect/FieldUtil.java     |  8 +-
 .../cn/hutool/core/reflect/MethodUtil.java    | 22 ++---
 .../cn/hutool/core/text/CharSequenceUtil.java | 20 +++--
 .../cn/hutool/core/text/escape/XmlEscape.java |  3 +-
 .../core/text/finder/CharMatcherFinder.java   | 13 +--
 .../core/text/replacer/StrReplacer.java       |  7 +-
 .../main/java/cn/hutool/core/tree/Tree.java   | 30 +++----
 .../java/cn/hutool/core/util/ArrayUtil.java   | 36 ++++-----
 .../pattern/matcher/AlwaysTrueMatcher.java    |  2 +-
 .../pattern/matcher/BoolArrayMatcher.java     |  2 +-
 .../pattern/matcher/DayOfMonthMatcher.java    |  4 +-
 .../cron/pattern/matcher/PartMatcher.java     |  4 +-
 .../cron/pattern/matcher/PatternMatcher.java  | 16 ++--
 .../pattern/matcher/YearValueMatcher.java     |  2 +-
 .../extra/compress/archiver/Archiver.java     | 12 +--
 .../compress/archiver/SevenZArchiver.java     | 18 ++---
 .../compress/archiver/StreamArchiver.java     | 40 ++++-----
 .../extra/compress/extractor/Extractor.java   |  8 +-
 .../compress/extractor/SevenZExtractor.java   | 42 +++++-----
 .../compress/extractor/StreamExtractor.java   | 20 ++---
 .../main/java/cn/hutool/extra/ftp/Ftp.java    | 10 +--
 .../main/java/cn/hutool/extra/ssh/Sftp.java   | 18 ++---
 .../java/cn/hutool/json/InternalJSONUtil.java | 13 +--
 .../main/java/cn/hutool/json/JSONArray.java   | 48 +++++------
 .../main/java/cn/hutool/json/JSONObject.java  | 50 ++++++------
 .../main/java/cn/hutool/json/JSONParser.java  | 17 ++--
 .../java/cn/hutool/json/ObjectMapper.java     | 81 ++++++++++---------
 .../excel/sax/handler/AbstractRowHandler.java |  6 +-
 40 files changed, 327 insertions(+), 415 deletions(-)
 delete mode 100755 hutool-core/src/main/java/cn/hutool/core/lang/func/Editor.java
 delete mode 100755 hutool-core/src/main/java/cn/hutool/core/lang/func/Filter.java
 delete mode 100755 hutool-core/src/main/java/cn/hutool/core/lang/func/Matcher.java
 delete mode 100644 hutool-core/src/main/java/cn/hutool/core/lang/func/Replacer.java

diff --git a/hutool-core/src/main/java/cn/hutool/core/bean/BeanUtil.java b/hutool-core/src/main/java/cn/hutool/core/bean/BeanUtil.java
index ed66d5b77..c132797d6 100755
--- a/hutool-core/src/main/java/cn/hutool/core/bean/BeanUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/bean/BeanUtil.java
@@ -7,7 +7,6 @@ import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.collection.ListUtil;
 import cn.hutool.core.collection.SetUtil;
 import cn.hutool.core.convert.Convert;
-import cn.hutool.core.lang.func.Editor;
 import cn.hutool.core.lang.mutable.MutableEntry;
 import cn.hutool.core.map.CaseInsensitiveMap;
 import cn.hutool.core.map.MapUtil;
@@ -36,6 +35,7 @@ import java.util.Map;
 import java.util.Set;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
+import java.util.function.UnaryOperator;
 import java.util.stream.Collectors;
 
 /**
@@ -529,7 +529,7 @@ public class BeanUtil {
 	 */
 	public static Map<String, Object> beanToMap(final Object bean, final String... properties) {
 		int mapSize = 16;
-		Editor<MutableEntry<String, Object>> editor = null;
+		UnaryOperator<MutableEntry<String, Object>> editor = null;
 		if (ArrayUtil.isNotEmpty(properties)) {
 			mapSize = properties.length;
 			final Set<String> propertiesSet = SetUtil.of(properties);
@@ -583,7 +583,7 @@ public class BeanUtil {
 
 	/**
 	 * 对象转Map<br>
-	 * 通过实现{@link Editor} 可以自定义字段值，如果这个Editor返回null则忽略这个字段，以便实现：
+	 * 通过实现{@link UnaryOperator} 可以自定义字段值，如果这个Editor返回null则忽略这个字段，以便实现：
 	 *
 	 * <pre>
 	 * 1. 字段筛选，可以去除不需要的字段
@@ -599,7 +599,7 @@ public class BeanUtil {
 	 * @since 4.0.5
 	 */
 	public static Map<String, Object> beanToMap(final Object bean, final Map<String, Object> targetMap,
-												final boolean ignoreNullValue, final Editor<MutableEntry<String, Object>> keyEditor) {
+												final boolean ignoreNullValue, final UnaryOperator<MutableEntry<String, Object>> keyEditor) {
 		if (null == bean) {
 			return null;
 		}
@@ -762,7 +762,7 @@ public class BeanUtil {
 	 * @return bean
 	 * @since 5.6.4
 	 */
-	public static <T> T edit(final T bean, final Editor<Field> editor) {
+	public static <T> T edit(final T bean, final UnaryOperator<Field> editor) {
 		if (bean == null) {
 			return null;
 		}
@@ -772,7 +772,7 @@ public class BeanUtil {
 			if (ModifierUtil.isStatic(field)) {
 				continue;
 			}
-			editor.edit(field);
+			editor.apply(field);
 		}
 		return bean;
 	}
diff --git a/hutool-core/src/main/java/cn/hutool/core/bean/copier/CopyOptions.java b/hutool-core/src/main/java/cn/hutool/core/bean/copier/CopyOptions.java
index 9e943877c..3cc1955e6 100755
--- a/hutool-core/src/main/java/cn/hutool/core/bean/copier/CopyOptions.java
+++ b/hutool-core/src/main/java/cn/hutool/core/bean/copier/CopyOptions.java
@@ -2,7 +2,6 @@ package cn.hutool.core.bean.copier;
 
 import cn.hutool.core.convert.Convert;
 import cn.hutool.core.convert.Converter;
-import cn.hutool.core.lang.func.Editor;
 import cn.hutool.core.lang.func.Func1;
 import cn.hutool.core.lang.func.LambdaUtil;
 import cn.hutool.core.lang.mutable.MutableEntry;
@@ -14,6 +13,7 @@ import java.lang.reflect.Type;
 import java.util.Map;
 import java.util.Set;
 import java.util.function.BiPredicate;
+import java.util.function.UnaryOperator;
 
 /**
  * 属性拷贝选项<br>
@@ -53,7 +53,7 @@ public class CopyOptions implements Serializable {
 	/**
 	 * 字段属性名和属性值编辑器，，用于自定义属性转换规则（例如驼峰转下划线等），自定义属性值转换规则（例如null转""等）
 	 */
-	protected Editor<MutableEntry<String, Object>> fieldEditor;
+	protected UnaryOperator<MutableEntry<String, Object>> fieldEditor;
 
 	/**
 	 * 是否支持transient关键字修饰和@Transient注解，如果支持，被修饰的字段或方法对应的字段将被忽略。
@@ -250,7 +250,7 @@ public class CopyOptions implements Serializable {
 	 * @return CopyOptions
 	 * @since 5.4.2
 	 */
-	public CopyOptions setFieldEditor(final Editor<MutableEntry<String, Object>> editor) {
+	public CopyOptions setFieldEditor(final UnaryOperator<MutableEntry<String, Object>> editor) {
 		this.fieldEditor = editor;
 		return this;
 	}
@@ -266,7 +266,7 @@ public class CopyOptions implements Serializable {
 	protected MutableEntry<String, Object> editField(final String fieldName, final Object fieldValue) {
 		final MutableEntry<String, Object> entry = new MutableEntry<>(fieldName, fieldValue);
 		return (null != this.fieldEditor) ?
-				this.fieldEditor.edit(entry) : entry;
+				this.fieldEditor.apply(entry) : entry;
 	}
 
 	/**
diff --git a/hutool-core/src/main/java/cn/hutool/core/collection/iter/IterUtil.java b/hutool-core/src/main/java/cn/hutool/core/collection/iter/IterUtil.java
index 45ad78135..214b15063 100644
--- a/hutool-core/src/main/java/cn/hutool/core/collection/iter/IterUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/collection/iter/IterUtil.java
@@ -2,7 +2,6 @@ package cn.hutool.core.collection.iter;
 
 import cn.hutool.core.collection.ListUtil;
 import cn.hutool.core.lang.Assert;
-import cn.hutool.core.lang.func.Filter;
 import cn.hutool.core.map.MapUtil;
 import cn.hutool.core.reflect.FieldUtil;
 import cn.hutool.core.reflect.MethodUtil;
@@ -623,27 +622,27 @@ public class IterUtil {
 	/**
 	 * 过滤{@link Iterator}并将过滤后满足条件的元素添加到List中
 	 *
-	 * @param <E>    元素类型
-	 * @param iter   {@link Iterator}
-	 * @param filter 过滤器，保留{@link Filter#accept(Object)}为{@code true}的元素
+	 * @param <E>       元素类型
+	 * @param iter      {@link Iterator}
+	 * @param predicate 过滤器，{@link Predicate#test(Object)}为{@code true}保留
 	 * @return ArrayList
 	 * @since 5.7.22
 	 */
-	public static <E> List<E> filterToList(final Iterator<E> iter, final Predicate<E> filter) {
-		return ListUtil.of(filtered(iter, filter));
+	public static <E> List<E> filterToList(final Iterator<E> iter, final Predicate<E> predicate) {
+		return ListUtil.of(filtered(iter, predicate));
 	}
 
 	/**
 	 * 获取一个新的 {@link FilterIter}，用于过滤指定元素
 	 *
-	 * @param iterator 被包装的 {@link Iterator}
-	 * @param filter   过滤断言，当{@link Filter#accept(Object)}为{@code true}时保留元素，{@code false}抛弃元素
-	 * @param <E>      元素类型
+	 * @param iterator  被包装的 {@link Iterator}
+	 * @param predicate 过滤断言，{@link Predicate#test(Object)}为{@code true}保留元素。
+	 * @param <E>       元素类型
 	 * @return {@link FilterIter}
 	 * @since 5.8.0
 	 */
-	public static <E> FilterIter<E> filtered(final Iterator<? extends E> iterator, final Predicate<? super E> filter) {
-		return new FilterIter<>(iterator, filter);
+	public static <E> FilterIter<E> filtered(final Iterator<? extends E> iterator, final Predicate<? super E> predicate) {
+		return new FilterIter<>(iterator, predicate);
 	}
 
 	/**
diff --git a/hutool-core/src/main/java/cn/hutool/core/compress/ZipReader.java b/hutool-core/src/main/java/cn/hutool/core/compress/ZipReader.java
index 5ad0c0cc0..9a3d840b0 100755
--- a/hutool-core/src/main/java/cn/hutool/core/compress/ZipReader.java
+++ b/hutool-core/src/main/java/cn/hutool/core/compress/ZipReader.java
@@ -3,7 +3,6 @@ package cn.hutool.core.compress;
 import cn.hutool.core.io.FileUtil;
 import cn.hutool.core.io.IORuntimeException;
 import cn.hutool.core.io.IoUtil;
-import cn.hutool.core.lang.func.Filter;
 import cn.hutool.core.text.StrUtil;
 
 import java.io.Closeable;
@@ -13,6 +12,7 @@ import java.io.InputStream;
 import java.nio.charset.Charset;
 import java.util.Enumeration;
 import java.util.function.Consumer;
+import java.util.function.Predicate;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipFile;
 import java.util.zip.ZipInputStream;
@@ -134,14 +134,14 @@ public class ZipReader implements Closeable {
 	 * 解压到指定目录中
 	 *
 	 * @param outFile     解压到的目录
-	 * @param entryFilter 过滤器，排除不需要的文件
+	 * @param entryFilter 过滤器，只保留{@link Predicate#test(Object)}结果为{@code true}的文件
 	 * @return 解压的目录
 	 * @throws IORuntimeException IO异常
 	 * @since 5.7.12
 	 */
-	public File readTo(final File outFile, final Filter<ZipEntry> entryFilter) throws IORuntimeException {
+	public File readTo(final File outFile, final Predicate<ZipEntry> entryFilter) throws IORuntimeException {
 		read((zipEntry) -> {
-			if (null == entryFilter || entryFilter.accept(zipEntry)) {
+			if (null == entryFilter || entryFilter.test(zipEntry)) {
 				//gitee issue #I4ZDQI
 				String path = zipEntry.getName();
 				if (FileUtil.isWindows()) {
diff --git a/hutool-core/src/main/java/cn/hutool/core/io/watch/WatchServer.java b/hutool-core/src/main/java/cn/hutool/core/io/watch/WatchServer.java
index bb6e3ddcb..aba722d52 100755
--- a/hutool-core/src/main/java/cn/hutool/core/io/watch/WatchServer.java
+++ b/hutool-core/src/main/java/cn/hutool/core/io/watch/WatchServer.java
@@ -1,7 +1,6 @@
 package cn.hutool.core.io.watch;
 
 import cn.hutool.core.io.IoUtil;
-import cn.hutool.core.lang.func.Filter;
 import cn.hutool.core.util.ArrayUtil;
 
 import java.io.Closeable;
@@ -21,6 +20,7 @@ import java.nio.file.WatchService;
 import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.function.Predicate;
 
 /**
  * 文件监听服务，此服务可以同时监听多个路径。
@@ -129,10 +129,10 @@ public class WatchServer extends Thread implements Closeable, Serializable {
 	 * 执行事件获取并处理
 	 *
 	 * @param action     监听回调函数，实现此函数接口用于处理WatchEvent事件
-	 * @param watchFilter 监听过滤接口，通过实现此接口过滤掉不需要监听的情况，null表示不过滤
+	 * @param watchFilter 监听过滤接口，通过实现此接口过滤掉不需要监听的情况，{@link Predicate#test(Object)}为{@code true}保留，null表示不过滤
 	 * @since 5.4.0
 	 */
-	public void watch(final WatchAction action, final Filter<WatchEvent<?>> watchFilter) {
+	public void watch(final WatchAction action, final Predicate<WatchEvent<?>> watchFilter) {
 		final WatchKey wk;
 		try {
 			wk = watchService.take();
@@ -146,7 +146,7 @@ public class WatchServer extends Thread implements Closeable, Serializable {
 
 		for (final WatchEvent<?> event : wk.pollEvents()) {
 			// 如果监听文件，检查当前事件是否与所监听文件关联
-			if (null != watchFilter && false == watchFilter.accept(event)) {
+			if (null != watchFilter && false == watchFilter.test(event)) {
 				continue;
 			}
 
@@ -160,9 +160,9 @@ public class WatchServer extends Thread implements Closeable, Serializable {
 	 * 执行事件获取并处理
 	 *
 	 * @param watcher     {@link Watcher}
-	 * @param watchFilter 监听过滤接口，通过实现此接口过滤掉不需要监听的情况，null表示不过滤
+	 * @param watchFilter 监听过滤接口，通过实现此接口过滤掉不需要监听的情况，{@link Predicate#test(Object)}为{@code true}保留，null表示不过滤
 	 */
-	public void watch(final Watcher watcher, final Filter<WatchEvent<?>> watchFilter) {
+	public void watch(final Watcher watcher, final Predicate<WatchEvent<?>> watchFilter) {
 		watch((event, currentPath)->{
 			final WatchEvent.Kind<?> kind = event.kind();
 
diff --git a/hutool-core/src/main/java/cn/hutool/core/lang/func/Editor.java b/hutool-core/src/main/java/cn/hutool/core/lang/func/Editor.java
deleted file mode 100755
index d9376fd06..000000000
--- a/hutool-core/src/main/java/cn/hutool/core/lang/func/Editor.java
+++ /dev/null
@@ -1,24 +0,0 @@
-package cn.hutool.core.lang.func;
-
-/**
- * 编辑器接口，常用于对于集合中的元素做统一编辑<br>
- * 此编辑器两个作用：
- *
- * <pre>
- * 1、如果返回值为{@code null}，表示此值被抛弃
- * 2、对对象做修改
- * </pre>
- *
- * @param <T> 被编辑对象类型
- * @author Looly
- */
-@FunctionalInterface
-public interface Editor<T> {
-	/**
-	 * 修改过滤后的结果
-	 *
-	 * @param t 被过滤的对象
-	 * @return 修改后的对象，如果被过滤返回{@code null}
-	 */
-	T edit(T t);
-}
diff --git a/hutool-core/src/main/java/cn/hutool/core/lang/func/Filter.java b/hutool-core/src/main/java/cn/hutool/core/lang/func/Filter.java
deleted file mode 100755
index 45803eb2e..000000000
--- a/hutool-core/src/main/java/cn/hutool/core/lang/func/Filter.java
+++ /dev/null
@@ -1,17 +0,0 @@
-package cn.hutool.core.lang.func;
-
-/**
- * 过滤器接口
- *
- * @author Looly
- */
-@FunctionalInterface
-public interface Filter<T> {
-	/**
-	 * 是否接受对象
-	 *
-	 * @param t 检查的对象
-	 * @return 是否接受对象
-	 */
-	boolean accept(T t);
-}
diff --git a/hutool-core/src/main/java/cn/hutool/core/lang/func/LambdaInfo.java b/hutool-core/src/main/java/cn/hutool/core/lang/func/LambdaInfo.java
index 6012b6c0f..a9563e9cf 100644
--- a/hutool-core/src/main/java/cn/hutool/core/lang/func/LambdaInfo.java
+++ b/hutool-core/src/main/java/cn/hutool/core/lang/func/LambdaInfo.java
@@ -24,31 +24,31 @@ public class LambdaInfo {
 	private final Class<?> clazz;
 	private final SerializedLambda lambda;
 
-	public LambdaInfo(Executable executable, SerializedLambda lambda) {
+	public LambdaInfo(final Executable executable, final SerializedLambda lambda) {
 		if (executable instanceof Method) {
-			Method method = (Method) executable;
+			final Method method = (Method) executable;
 			this.parameterTypes = method.getGenericParameterTypes();
 			this.returnType = method.getGenericReturnType();
 			this.name = method.getName();
 		} else if (executable instanceof Constructor) {
-			Constructor<?> constructor = (Constructor<?>) executable;
+			final Constructor<?> constructor = (Constructor<?>) executable;
 			this.parameterTypes = constructor.getGenericParameterTypes();
 			this.returnType = constructor.getDeclaringClass();
 			this.name = constructor.getName();
 		} else {
 			throw new IllegalArgumentException("Unsupported executable type: " + executable.getClass());
 		}
-		int index = lambda.getInstantiatedMethodType().indexOf(";)");
+		final int index = lambda.getInstantiatedMethodType().indexOf(";)");
 		if (index > -1) {
-			boolean isArray = lambda.getInstantiatedMethodType().startsWith("([");
+			final boolean isArray = lambda.getInstantiatedMethodType().startsWith("([");
 			if (isArray) {
 				try {
 					this.instantiatedTypes = new Type[]{Class.forName(lambda.getInstantiatedMethodType().replace("/", ".").substring(0, index).substring(1) + ";")};
-				} catch (ClassNotFoundException e) {
+				} catch (final ClassNotFoundException e) {
 					throw new IllegalStateException(e);
 				}
 			} else {
-				String[] instantiatedTypeNames = lambda.getInstantiatedMethodType().substring(2, index).split(";L");
+				final String[] instantiatedTypeNames = lambda.getInstantiatedMethodType().substring(2, index).split(";L");
 				this.instantiatedTypes = new Type[instantiatedTypeNames.length];
 				for (int i = 0; i < instantiatedTypeNames.length; i++) {
 					this.instantiatedTypes[i] = ClassLoaderUtil.loadClass(instantiatedTypeNames[i]);
diff --git a/hutool-core/src/main/java/cn/hutool/core/lang/func/Matcher.java b/hutool-core/src/main/java/cn/hutool/core/lang/func/Matcher.java
deleted file mode 100755
index bf293a0a9..000000000
--- a/hutool-core/src/main/java/cn/hutool/core/lang/func/Matcher.java
+++ /dev/null
@@ -1,18 +0,0 @@
-package cn.hutool.core.lang.func;
-
-/**
- * 匹配接口
- *
- * @param <T> 匹配的对象类型
- * @author Looly
- */
-@FunctionalInterface
-public interface Matcher<T> {
-	/**
-	 * 给定对象是否匹配
-	 *
-	 * @param t 对象
-	 * @return 是否匹配
-	 */
-	boolean match(T t);
-}
diff --git a/hutool-core/src/main/java/cn/hutool/core/lang/func/Replacer.java b/hutool-core/src/main/java/cn/hutool/core/lang/func/Replacer.java
deleted file mode 100644
index 806b8b2c1..000000000
--- a/hutool-core/src/main/java/cn/hutool/core/lang/func/Replacer.java
+++ /dev/null
@@ -1,22 +0,0 @@
-package cn.hutool.core.lang.func;
-
-/**
- * 替换器<br>
- * 通过实现此接口完成指定类型对象的替换操作，替换后的目标类型依旧为指定类型
- *
- * @author looly
- *
- * @param <T> 被替换操作的类型
- * @since 4.1.5
- */
-@FunctionalInterface
-public interface Replacer<T> {
-
-	/**
-	 * 替换指定类型为目标类型
-	 *
-	 * @param t 被替换的对象
-	 * @return 替代后的对象
-	 */
-	T replace(T t);
-}
diff --git a/hutool-core/src/main/java/cn/hutool/core/map/MapUtil.java b/hutool-core/src/main/java/cn/hutool/core/map/MapUtil.java
index e58cd2b25..00bc6c104 100755
--- a/hutool-core/src/main/java/cn/hutool/core/map/MapUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/map/MapUtil.java
@@ -5,8 +5,6 @@ import cn.hutool.core.collection.ListUtil;
 import cn.hutool.core.collection.iter.ArrayIter;
 import cn.hutool.core.collection.iter.IterUtil;
 import cn.hutool.core.convert.Convert;
-import cn.hutool.core.lang.func.Editor;
-import cn.hutool.core.lang.func.Filter;
 import cn.hutool.core.reflect.ConstructorUtil;
 import cn.hutool.core.reflect.TypeReference;
 import cn.hutool.core.text.StrUtil;
@@ -32,6 +30,8 @@ import java.util.TreeMap;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.BiFunction;
 import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.UnaryOperator;
 import java.util.stream.Collectors;
 
 /**
@@ -658,7 +658,7 @@ public class MapUtil {
 	 * @return 编辑后的Map
 	 */
 	@SuppressWarnings("unchecked")
-	public static <K, V> Map<K, V> edit(final Map<K, V> map, final Editor<Entry<K, V>> editor) {
+	public static <K, V> Map<K, V> edit(final Map<K, V> map, final UnaryOperator<Entry<K, V>> editor) {
 		if (null == map || null == editor) {
 			return map;
 		}
@@ -673,7 +673,7 @@ public class MapUtil {
 
 		Entry<K, V> modified;
 		for (final Entry<K, V> entry : map.entrySet()) {
-			modified = editor.edit(entry);
+			modified = editor.apply(entry);
 			if (null != modified) {
 				map2.put(modified.getKey(), modified.getValue());
 			}
@@ -689,18 +689,18 @@ public class MapUtil {
 	 * 1、过滤出需要的对象，如果返回null表示这个元素对象抛弃
 	 * </pre>
 	 *
-	 * @param <K>    Key类型
-	 * @param <V>    Value类型
-	 * @param map    Map
-	 * @param filter 过滤器接口，{@code null}返回原Map
+	 * @param <K>       Key类型
+	 * @param <V>       Value类型
+	 * @param map       Map
+	 * @param predicate 过滤器接口，{@link Predicate#test(Object)}为{@code true}保留，{@code null}返回原Map
 	 * @return 过滤后的Map
 	 * @since 3.1.0
 	 */
-	public static <K, V> Map<K, V> filter(final Map<K, V> map, final Filter<Entry<K, V>> filter) {
-		if (null == map || null == filter) {
+	public static <K, V> Map<K, V> filter(final Map<K, V> map, final Predicate<Entry<K, V>> predicate) {
+		if (null == map || null == predicate) {
 			return map;
 		}
-		return edit(map, t -> filter.accept(t) ? t : null);
+		return edit(map, t -> predicate.test(t) ? t : null);
 	}
 
 
diff --git a/hutool-core/src/main/java/cn/hutool/core/net/NetUtil.java b/hutool-core/src/main/java/cn/hutool/core/net/NetUtil.java
index 186ca5279..34aa7fc90 100755
--- a/hutool-core/src/main/java/cn/hutool/core/net/NetUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/net/NetUtil.java
@@ -5,10 +5,9 @@ import cn.hutool.core.collection.iter.EnumerationIter;
 import cn.hutool.core.exceptions.UtilException;
 import cn.hutool.core.io.IORuntimeException;
 import cn.hutool.core.io.IoUtil;
-import cn.hutool.core.lang.func.Filter;
+import cn.hutool.core.text.StrUtil;
 import cn.hutool.core.util.JNDIUtil;
 import cn.hutool.core.util.RandomUtil;
-import cn.hutool.core.text.StrUtil;
 
 import javax.naming.NamingException;
 import javax.naming.directory.Attribute;
@@ -40,6 +39,7 @@ import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Set;
 import java.util.TreeSet;
+import java.util.function.Predicate;
 
 /**
  * 网络相关工具
@@ -424,11 +424,11 @@ public class NetUtil {
 	/**
 	 * 获取所有满足过滤条件的本地IP地址对象
 	 *
-	 * @param addressFilter 过滤器，null表示不过滤，获取所有地址
+	 * @param addressPredicate 过滤器，{@link Predicate#test(Object)}为{@code true}保留，null表示不过滤，获取所有地址
 	 * @return 过滤后的地址对象列表
 	 * @since 4.5.17
 	 */
-	public static LinkedHashSet<InetAddress> localAddressList(final Filter<InetAddress> addressFilter) {
+	public static LinkedHashSet<InetAddress> localAddressList(final Predicate<InetAddress> addressPredicate) {
 		final Enumeration<NetworkInterface> networkInterfaces;
 		try {
 			networkInterfaces = NetworkInterface.getNetworkInterfaces();
@@ -447,7 +447,7 @@ public class NetUtil {
 			final Enumeration<InetAddress> inetAddresses = networkInterface.getInetAddresses();
 			while (inetAddresses.hasMoreElements()) {
 				final InetAddress inetAddress = inetAddresses.nextElement();
-				if (inetAddress != null && (null == addressFilter || addressFilter.accept(inetAddress))) {
+				if (inetAddress != null && (null == addressPredicate || addressPredicate.test(inetAddress))) {
 					ipSet.add(inetAddress);
 				}
 			}
@@ -462,7 +462,7 @@ public class NetUtil {
 	 * 此方法不会抛出异常，获取失败将返回{@code null}<br>
 	 * <p>
 	 * 参考：<a href="http://stackoverflow.com/questions/9481865/getting-the-ip-address-of-the-current-machine-using-java">
-	 *     http://stackoverflow.com/questions/9481865/getting-the-ip-address-of-the-current-machine-using-java</a>
+	 * http://stackoverflow.com/questions/9481865/getting-the-ip-address-of-the-current-machine-using-java</a>
 	 *
 	 * @return 本机网卡IP地址，获取失败返回{@code null}
 	 * @since 3.0.7
diff --git a/hutool-core/src/main/java/cn/hutool/core/reflect/FieldUtil.java b/hutool-core/src/main/java/cn/hutool/core/reflect/FieldUtil.java
index 172cdcf0b..c52728c6e 100644
--- a/hutool-core/src/main/java/cn/hutool/core/reflect/FieldUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/reflect/FieldUtil.java
@@ -4,7 +4,6 @@ import cn.hutool.core.annotation.Alias;
 import cn.hutool.core.convert.Convert;
 import cn.hutool.core.exceptions.UtilException;
 import cn.hutool.core.lang.Assert;
-import cn.hutool.core.lang.func.Filter;
 import cn.hutool.core.map.MapUtil;
 import cn.hutool.core.map.WeakConcurrentMap;
 import cn.hutool.core.text.StrUtil;
@@ -13,6 +12,7 @@ import cn.hutool.core.util.ArrayUtil;
 import java.lang.reflect.Field;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.function.Predicate;
 
 /**
  * 反射中{@link Field}字段工具类，包括字段获取和字段赋值。
@@ -125,13 +125,13 @@ public class FieldUtil {
 	 * 如果子类与父类中存在同名字段，则这两个字段同时存在，子类字段在前，父类字段在后。
 	 *
 	 * @param beanClass   类
-	 * @param fieldFilter field过滤器，过滤掉不需要的field
+	 * @param fieldPredicate field过滤器，过滤掉不需要的field，{@link Predicate#test(Object)}为{@code true}保留，null表示全部保留
 	 * @return 字段列表
 	 * @throws SecurityException 安全检查异常
 	 * @since 5.7.14
 	 */
-	public static Field[] getFields(final Class<?> beanClass, final Filter<Field> fieldFilter) throws SecurityException {
-		return ArrayUtil.filter(getFields(beanClass), fieldFilter);
+	public static Field[] getFields(final Class<?> beanClass, final Predicate<Field> fieldPredicate) throws SecurityException {
+		return ArrayUtil.filter(getFields(beanClass), fieldPredicate);
 	}
 
 	/**
diff --git a/hutool-core/src/main/java/cn/hutool/core/reflect/MethodUtil.java b/hutool-core/src/main/java/cn/hutool/core/reflect/MethodUtil.java
index c00ca0102..6b212c9d2 100644
--- a/hutool-core/src/main/java/cn/hutool/core/reflect/MethodUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/reflect/MethodUtil.java
@@ -9,7 +9,6 @@ import cn.hutool.core.exceptions.InvocationTargetRuntimeException;
 import cn.hutool.core.exceptions.UtilException;
 import cn.hutool.core.lang.Assert;
 import cn.hutool.core.lang.Singleton;
-import cn.hutool.core.lang.func.Filter;
 import cn.hutool.core.map.WeakConcurrentMap;
 import cn.hutool.core.text.StrUtil;
 import cn.hutool.core.util.ArrayUtil;
@@ -21,6 +20,7 @@ import java.util.Arrays;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
+import java.util.function.Predicate;
 
 /**
  * 反射中{@link Method}相关工具类，包括方法获取和方法执行<br>
@@ -67,21 +67,21 @@ public class MethodUtil {
 	/**
 	 * 获得指定类过滤后的Public方法列表<br>
 	 *
-	 * @param clazz  查找方法的类
-	 * @param filter 过滤器
+	 * @param clazz     查找方法的类
+	 * @param predicate 过滤器，{@link Predicate#test(Object)}为{@code true}保留，null表示保留全部
 	 * @return 过滤后的方法数组
 	 */
-	public static Method[] getPublicMethods(final Class<?> clazz, final Filter<Method> filter) {
+	public static Method[] getPublicMethods(final Class<?> clazz, final Predicate<Method> predicate) {
 		if (null == clazz) {
 			return null;
 		}
 
 		final Method[] methods = getPublicMethods(clazz);
-		if (null == filter) {
+		if (null == predicate) {
 			return methods;
 		}
 
-		return ArrayUtil.filter(methods, filter);
+		return ArrayUtil.filter(methods, predicate);
 	}
 
 	/**
@@ -298,16 +298,16 @@ public class MethodUtil {
 	/**
 	 * 获得指定类过滤后的Public方法列表
 	 *
-	 * @param clazz  查找方法的类
-	 * @param filter 过滤器
+	 * @param clazz     查找方法的类
+	 * @param predicate 过滤器，{@link Predicate#test(Object)}为{@code true}保留，null表示全部保留。
 	 * @return 过滤后的方法列表
 	 * @throws SecurityException 安全异常
 	 */
-	public static Method[] getMethods(final Class<?> clazz, final Filter<Method> filter) throws SecurityException {
+	public static Method[] getMethods(final Class<?> clazz, final Predicate<Method> predicate) throws SecurityException {
 		if (null == clazz) {
 			return null;
 		}
-		return ArrayUtil.filter(getMethods(clazz), filter);
+		return ArrayUtil.filter(getMethods(clazz), predicate);
 	}
 
 	/**
@@ -566,7 +566,7 @@ public class MethodUtil {
 	 * @param args   参数对象
 	 * @return 结果
 	 * @throws InvocationTargetException 目标方法执行异常
-	 * @throws IllegalAccessException           访问权限异常
+	 * @throws IllegalAccessException    访问权限异常
 	 */
 	@SuppressWarnings("unchecked")
 	public static <T> T invokeRaw(final Object obj, final Method method, final Object... args) throws InvocationTargetException, IllegalAccessException {
diff --git a/hutool-core/src/main/java/cn/hutool/core/text/CharSequenceUtil.java b/hutool-core/src/main/java/cn/hutool/core/text/CharSequenceUtil.java
index e3fb13a37..f6280bfde 100755
--- a/hutool-core/src/main/java/cn/hutool/core/text/CharSequenceUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/text/CharSequenceUtil.java
@@ -4,9 +4,9 @@ import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.comparator.VersionComparator;
 import cn.hutool.core.convert.Convert;
 import cn.hutool.core.lang.Assert;
-import cn.hutool.core.lang.func.Filter;
-import cn.hutool.core.lang.func.Matcher;
 import cn.hutool.core.lang.func.Func1;
+import cn.hutool.core.math.NumberUtil;
+import cn.hutool.core.regex.ReUtil;
 import cn.hutool.core.text.finder.CharFinder;
 import cn.hutool.core.text.finder.Finder;
 import cn.hutool.core.text.finder.StrFinder;
@@ -14,8 +14,6 @@ import cn.hutool.core.text.split.SplitUtil;
 import cn.hutool.core.util.ArrayUtil;
 import cn.hutool.core.util.CharUtil;
 import cn.hutool.core.util.CharsetUtil;
-import cn.hutool.core.math.NumberUtil;
-import cn.hutool.core.regex.ReUtil;
 
 import java.nio.ByteBuffer;
 import java.nio.charset.Charset;
@@ -3701,7 +3699,7 @@ public class CharSequenceUtil {
 
 	/**
 	 * 替换所有正则匹配的文本，并使用自定义函数决定如何替换<br>
-	 * replaceFun可以通过{@link Matcher}提取出匹配到的内容的不同部分，然后经过重新处理、组装变成新的内容放回原位。
+	 * replaceFun可以提取出匹配到的内容的不同部分，然后经过重新处理、组装变成新的内容放回原位。
 	 *
 	 * <pre class="code">
 	 *     replace(this.content, "(\\d+)", parameters -&gt; "-" + parameters.group(1) + "-")
@@ -3994,12 +3992,12 @@ public class CharSequenceUtil {
 	 * 过滤字符串
 	 *
 	 * @param str    字符串
-	 * @param filter 过滤器，{@link Filter#accept(Object)}返回为{@code true}的保留字符
+	 * @param predicate 过滤器，{@link Predicate#test(Object)}为{@code true}保留字符
 	 * @return 过滤后的字符串
 	 * @since 5.4.0
 	 */
-	public static String filter(final CharSequence str, final Filter<Character> filter) {
-		if (str == null || filter == null) {
+	public static String filter(final CharSequence str, final Predicate<Character> predicate) {
+		if (str == null || predicate == null) {
 			return str(str);
 		}
 
@@ -4008,7 +4006,7 @@ public class CharSequenceUtil {
 		char c;
 		for (int i = 0; i < len; i++) {
 			c = str.charAt(i);
-			if (filter.accept(c)) {
+			if (predicate.test(c)) {
 				sb.append(c);
 			}
 		}
@@ -4361,12 +4359,12 @@ public class CharSequenceUtil {
 	 * @return 是否全部匹配
 	 * @since 3.2.3
 	 */
-	public static boolean isAllCharMatch(final CharSequence value, final Matcher<Character> matcher) {
+	public static boolean isAllCharMatch(final CharSequence value, final Predicate<Character> matcher) {
 		if (StrUtil.isBlank(value)) {
 			return false;
 		}
 		for (int i = value.length(); --i >= 0; ) {
-			if (false == matcher.match(value.charAt(i))) {
+			if (false == matcher.test(value.charAt(i))) {
 				return false;
 			}
 		}
diff --git a/hutool-core/src/main/java/cn/hutool/core/text/escape/XmlEscape.java b/hutool-core/src/main/java/cn/hutool/core/text/escape/XmlEscape.java
index 8aba9e2a7..bd983f2e5 100644
--- a/hutool-core/src/main/java/cn/hutool/core/text/escape/XmlEscape.java
+++ b/hutool-core/src/main/java/cn/hutool/core/text/escape/XmlEscape.java
@@ -5,7 +5,8 @@ import cn.hutool.core.text.replacer.ReplacerChain;
 
 /**
  * XML特殊字符转义<br>
- * 见：https://stackoverflow.com/questions/1091945/what-characters-do-i-need-to-escape-in-xml-documents<br>
+ * 见：<a href="https://stackoverflow.com/questions/1091945/what-characters-do-i-need-to-escape-in-xml-documents">
+ *     https://stackoverflow.com/questions/1091945/what-characters-do-i-need-to-escape-in-xml-documents</a><br>
  *
  * <pre>
  * 	 &amp; (ampersand) 替换为 &amp;amp;
diff --git a/hutool-core/src/main/java/cn/hutool/core/text/finder/CharMatcherFinder.java b/hutool-core/src/main/java/cn/hutool/core/text/finder/CharMatcherFinder.java
index f6e0d0028..7f9b17b00 100755
--- a/hutool-core/src/main/java/cn/hutool/core/text/finder/CharMatcherFinder.java
+++ b/hutool-core/src/main/java/cn/hutool/core/text/finder/CharMatcherFinder.java
@@ -1,11 +1,12 @@
 package cn.hutool.core.text.finder;
 
 import cn.hutool.core.lang.Assert;
-import cn.hutool.core.lang.func.Matcher;
+
+import java.util.function.Predicate;
 
 /**
  * 字符匹配查找器<br>
- * 查找满足指定{@link Matcher} 匹配的字符所在位置，此类长用于查找某一类字符，如数字等
+ * 查找满足指定{@link Predicate} 匹配的字符所在位置，此类长用于查找某一类字符，如数字等
  *
  * @since 5.7.14
  * @author looly
@@ -13,13 +14,13 @@ import cn.hutool.core.lang.func.Matcher;
 public class CharMatcherFinder extends TextFinder {
 	private static final long serialVersionUID = 1L;
 
-	private final Matcher<Character> matcher;
+	private final Predicate<Character> matcher;
 
 	/**
 	 * 构造
 	 * @param matcher 被查找的字符匹配器
 	 */
-	public CharMatcherFinder(final Matcher<Character> matcher) {
+	public CharMatcherFinder(final Predicate<Character> matcher) {
 		this.matcher = matcher;
 	}
 
@@ -29,13 +30,13 @@ public class CharMatcherFinder extends TextFinder {
 		final int limit = getValidEndIndex();
 		if(negative){
 			for (int i = from; i > limit; i--) {
-				if(matcher.match(text.charAt(i))){
+				if(null == matcher || matcher.test(text.charAt(i))){
 					return i;
 				}
 			}
 		} else {
 			for (int i = from; i < limit; i++) {
-				if(matcher.match(text.charAt(i))){
+				if(null == matcher || matcher.test(text.charAt(i))){
 					return i;
 				}
 			}
diff --git a/hutool-core/src/main/java/cn/hutool/core/text/replacer/StrReplacer.java b/hutool-core/src/main/java/cn/hutool/core/text/replacer/StrReplacer.java
index c351b97c9..55c3a89ce 100755
--- a/hutool-core/src/main/java/cn/hutool/core/text/replacer/StrReplacer.java
+++ b/hutool-core/src/main/java/cn/hutool/core/text/replacer/StrReplacer.java
@@ -1,8 +1,7 @@
 package cn.hutool.core.text.replacer;
 
-import cn.hutool.core.lang.func.Replacer;
-
 import java.io.Serializable;
+import java.util.function.UnaryOperator;
 
 /**
  * 抽象字符串替换类<br>
@@ -11,7 +10,7 @@ import java.io.Serializable;
  * @author looly
  * @since 4.1.5
  */
-public abstract class StrReplacer implements Replacer<CharSequence>, Serializable {
+public abstract class StrReplacer implements UnaryOperator<CharSequence>, Serializable {
 	private static final long serialVersionUID = 1L;
 
 	/**
@@ -25,7 +24,7 @@ public abstract class StrReplacer implements Replacer<CharSequence>, Serializabl
 	protected abstract int replace(CharSequence str, int pos, StringBuilder out);
 
 	@Override
-	public CharSequence replace(final CharSequence t) {
+	public CharSequence apply(final CharSequence t) {
 		final int len = t.length();
 		final StringBuilder builder = new StringBuilder(len);
 		int pos = 0;//当前位置
diff --git a/hutool-core/src/main/java/cn/hutool/core/tree/Tree.java b/hutool-core/src/main/java/cn/hutool/core/tree/Tree.java
index ce94ba989..ce7762bde 100755
--- a/hutool-core/src/main/java/cn/hutool/core/tree/Tree.java
+++ b/hutool-core/src/main/java/cn/hutool/core/tree/Tree.java
@@ -2,11 +2,10 @@ package cn.hutool.core.tree;
 
 import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.lang.Assert;
-import cn.hutool.core.lang.func.Filter;
+import cn.hutool.core.text.StrUtil;
 import cn.hutool.core.util.ArrayUtil;
 import cn.hutool.core.util.CharUtil;
 import cn.hutool.core.util.ObjUtil;
-import cn.hutool.core.text.StrUtil;
 
 import java.io.PrintWriter;
 import java.io.StringWriter;
@@ -14,6 +13,7 @@ import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.function.Consumer;
+import java.util.function.Predicate;
 
 /**
  * 通过转换器将你的实体转化为TreeNodeMap节点实体 属性都存在此处,属性有序，可支持排序
@@ -202,28 +202,28 @@ public class Tree<T> extends LinkedHashMap<String, Object> implements Node<T> {
 
 	/**
 	 * 递归过滤并生成新的树<br>
-	 * 通过{@link Filter}指定的过滤规则，本节点或子节点满足过滤条件，则保留当前节点，否则抛弃节点及其子节点
+	 * 通过{@link Predicate}指定的过滤规则，本节点或子节点满足过滤条件，则保留当前节点，否则抛弃节点及其子节点
 	 *
-	 * @param filter 节点过滤规则函数，只需处理本级节点本身即可
+	 * @param predicate 节点过滤规则函数，只需处理本级节点本身即可，{@link Predicate#test(Object)}为{@code true}保留，null表示全部保留
 	 * @return 过滤后的节点，{@code null} 表示不满足过滤要求，丢弃之
-	 * @see #filter(Filter)
+	 * @see #filter(Predicate)
 	 * @since 5.7.17
 	 */
-	public Tree<T> filterNew(final Filter<Tree<T>> filter) {
-		return cloneTree().filter(filter);
+	public Tree<T> filterNew(final Predicate<Tree<T>> predicate) {
+		return cloneTree().filter(predicate);
 	}
 
 	/**
 	 * 递归过滤当前树，注意此方法会修改当前树<br>
-	 * 通过{@link Filter}指定的过滤规则，本节点或子节点满足过滤条件，则保留当前节点及其所有子节点，否则抛弃节点及其子节点
+	 * 通过{@link Predicate}指定的过滤规则，本节点或子节点满足过滤条件，则保留当前节点及其所有子节点，否则抛弃节点及其子节点
 	 *
-	 * @param filter 节点过滤规则函数，只需处理本级节点本身即可
+	 * @param predicate 节点过滤规则函数，只需处理本级节点本身即可，{@link Predicate#test(Object)}为{@code true}保留，null表示保留全部
 	 * @return 过滤后的节点，{@code null} 表示不满足过滤要求，丢弃之
-	 * @see #filterNew(Filter)
+	 * @see #filterNew(Predicate)
 	 * @since 5.7.17
 	 */
-	public Tree<T> filter(final Filter<Tree<T>> filter) {
-		if(filter.accept(this)){
+	public Tree<T> filter(final Predicate<Tree<T>> predicate) {
+		if (null == predicate || predicate.test(this)) {
 			// 本节点满足，则包括所有子节点都保留
 			return this;
 		}
@@ -234,12 +234,12 @@ public class Tree<T> extends LinkedHashMap<String, Object> implements Node<T> {
 			final List<Tree<T>> filteredChildren = new ArrayList<>(children.size());
 			Tree<T> filteredChild;
 			for (final Tree<T> child : children) {
-				filteredChild = child.filter(filter);
+				filteredChild = child.filter(predicate);
 				if (null != filteredChild) {
 					filteredChildren.add(filteredChild);
 				}
 			}
-			if(CollUtil.isNotEmpty(filteredChildren)){
+			if (CollUtil.isNotEmpty(filteredChildren)) {
 				// 子节点有符合过滤条件的节点，则本节点保留
 				return this.setChildren(filteredChildren);
 			} else {
@@ -258,7 +258,7 @@ public class Tree<T> extends LinkedHashMap<String, Object> implements Node<T> {
 	 * @return this
 	 */
 	public Tree<T> setChildren(final List<Tree<T>> children) {
-		if(null == children){
+		if (null == children) {
 			this.remove(treeNodeConfig.getChildrenKey());
 		}
 		this.put(treeNodeConfig.getChildrenKey(), children);
diff --git a/hutool-core/src/main/java/cn/hutool/core/util/ArrayUtil.java b/hutool-core/src/main/java/cn/hutool/core/util/ArrayUtil.java
index ed613a297..5400f7428 100755
--- a/hutool-core/src/main/java/cn/hutool/core/util/ArrayUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/util/ArrayUtil.java
@@ -6,9 +6,6 @@ import cn.hutool.core.collection.UniqueKeySet;
 import cn.hutool.core.comparator.CompareUtil;
 import cn.hutool.core.exceptions.UtilException;
 import cn.hutool.core.lang.Assert;
-import cn.hutool.core.lang.func.Editor;
-import cn.hutool.core.lang.func.Filter;
-import cn.hutool.core.lang.func.Matcher;
 import cn.hutool.core.map.MapUtil;
 import cn.hutool.core.text.StrJoiner;
 import cn.hutool.core.text.StrUtil;
@@ -27,6 +24,8 @@ import java.util.Map;
 import java.util.Random;
 import java.util.Set;
 import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.UnaryOperator;
 import java.util.stream.Collectors;
 
 /**
@@ -164,7 +163,7 @@ public class ArrayUtil extends PrimitiveArrayUtil {
 	 * @since 3.0.7
 	 */
 	@SuppressWarnings("unchecked")
-	public static <T> T firstMatch(final Matcher<T> matcher, final T... array) {
+	public static <T> T firstMatch(final Predicate<T> matcher, final T... array) {
 		final int index = matchIndex(matcher, array);
 		if (index < 0) {
 			return null;
@@ -183,7 +182,7 @@ public class ArrayUtil extends PrimitiveArrayUtil {
 	 * @since 5.6.6
 	 */
 	@SuppressWarnings("unchecked")
-	public static <T> int matchIndex(final Matcher<T> matcher, final T... array) {
+	public static <T> int matchIndex(final Predicate<T> matcher, final T... array) {
 		return matchIndex(matcher, 0, array);
 	}
 
@@ -198,11 +197,10 @@ public class ArrayUtil extends PrimitiveArrayUtil {
 	 * @since 5.7.3
 	 */
 	@SuppressWarnings("unchecked")
-	public static <T> int matchIndex(final Matcher<T> matcher, final int beginIndexInclude, final T... array) {
-		Assert.notNull(matcher, "Matcher must be not null !");
+	public static <T> int matchIndex(final Predicate<T> matcher, final int beginIndexInclude, final T... array) {
 		if (isNotEmpty(array)) {
 			for (int i = beginIndexInclude; i < array.length; i++) {
-				if (matcher.match(array[i])) {
+				if (null == matcher || matcher.test(array[i])) {
 					return i;
 				}
 			}
@@ -654,7 +652,7 @@ public class ArrayUtil extends PrimitiveArrayUtil {
 	 * @return 编辑后的数组
 	 * @since 5.3.3
 	 */
-	public static <T> T[] edit(final T[] array, final Editor<T> editor) {
+	public static <T> T[] edit(final T[] array, final UnaryOperator<T> editor) {
 		if (null == editor) {
 			return array;
 		}
@@ -662,7 +660,7 @@ public class ArrayUtil extends PrimitiveArrayUtil {
 		final ArrayList<T> list = new ArrayList<>(array.length);
 		T modified;
 		for (final T t : array) {
-			modified = editor.edit(t);
+			modified = editor.apply(t);
 			if (null != modified) {
 				list.add(modified);
 			}
@@ -676,20 +674,20 @@ public class ArrayUtil extends PrimitiveArrayUtil {
 	 * 过滤过程通过传入的Filter实现来过滤返回需要的元素内容，这个Filter实现可以实现以下功能：
 	 *
 	 * <pre>
-	 * 1、过滤出需要的对象，{@link Filter#accept(Object)}方法返回true的对象将被加入结果集合中
+	 * 1、过滤出需要的对象，{@link Predicate#test(Object)}为{@code true}对象将被加入结果集合中
 	 * </pre>
 	 *
-	 * @param <T>    数组元素类型
-	 * @param array  数组
-	 * @param filter 过滤器接口，用于定义过滤规则，{@code null}返回原集合
+	 * @param <T>       数组元素类型
+	 * @param array     数组
+	 * @param predicate 过滤器接口，用于定义过滤规则，{@link Predicate#test(Object)}为{@code true}保留，{@code null}返回原集合
 	 * @return 过滤后的数组
 	 * @since 3.2.1
 	 */
-	public static <T> T[] filter(final T[] array, final Filter<T> filter) {
-		if (null == array || null == filter) {
+	public static <T> T[] filter(final T[] array, final Predicate<T> predicate) {
+		if (null == array || null == predicate) {
 			return array;
 		}
-		return edit(array, t -> filter.accept(t) ? t : null);
+		return edit(array, t -> predicate.test(t) ? t : null);
 	}
 
 	/**
@@ -1240,8 +1238,8 @@ public class ArrayUtil extends PrimitiveArrayUtil {
 	 * @return 连接后的字符串
 	 * @since 5.3.3
 	 */
-	public static <T> String join(final T[] array, final CharSequence conjunction, final Editor<T> editor) {
-		return StrJoiner.of(conjunction).append(array, (t) -> String.valueOf(editor.edit(t))).toString();
+	public static <T> String join(final T[] array, final CharSequence conjunction, final UnaryOperator<T> editor) {
+		return StrJoiner.of(conjunction).append(array, (t) -> String.valueOf(editor.apply(t))).toString();
 	}
 
 	/**
diff --git a/hutool-cron/src/main/java/cn/hutool/cron/pattern/matcher/AlwaysTrueMatcher.java b/hutool-cron/src/main/java/cn/hutool/cron/pattern/matcher/AlwaysTrueMatcher.java
index 706a3a826..0c71014de 100644
--- a/hutool-cron/src/main/java/cn/hutool/cron/pattern/matcher/AlwaysTrueMatcher.java
+++ b/hutool-cron/src/main/java/cn/hutool/cron/pattern/matcher/AlwaysTrueMatcher.java
@@ -12,7 +12,7 @@ public class AlwaysTrueMatcher implements PartMatcher {
 	public static AlwaysTrueMatcher INSTANCE = new AlwaysTrueMatcher();
 
 	@Override
-	public boolean match(final Integer t) {
+	public boolean test(final Integer t) {
 		return true;
 	}
 
diff --git a/hutool-cron/src/main/java/cn/hutool/cron/pattern/matcher/BoolArrayMatcher.java b/hutool-cron/src/main/java/cn/hutool/cron/pattern/matcher/BoolArrayMatcher.java
index 0bd6fd589..601675993 100644
--- a/hutool-cron/src/main/java/cn/hutool/cron/pattern/matcher/BoolArrayMatcher.java
+++ b/hutool-cron/src/main/java/cn/hutool/cron/pattern/matcher/BoolArrayMatcher.java
@@ -37,7 +37,7 @@ public class BoolArrayMatcher implements PartMatcher {
 	}
 
 	@Override
-	public boolean match(final Integer value) {
+	public boolean test(final Integer value) {
 		if (null == value || value >= bValues.length) {
 			return false;
 		}
diff --git a/hutool-cron/src/main/java/cn/hutool/cron/pattern/matcher/DayOfMonthMatcher.java b/hutool-cron/src/main/java/cn/hutool/cron/pattern/matcher/DayOfMonthMatcher.java
index 61de1888b..865cb849a 100644
--- a/hutool-cron/src/main/java/cn/hutool/cron/pattern/matcher/DayOfMonthMatcher.java
+++ b/hutool-cron/src/main/java/cn/hutool/cron/pattern/matcher/DayOfMonthMatcher.java
@@ -30,9 +30,9 @@ public class DayOfMonthMatcher extends BoolArrayMatcher {
 	 * @return 是否匹配
 	 */
 	public boolean match(final int value, final int month, final boolean isLeapYear) {
-		return (super.match(value) // 在约定日范围内的某一天
+		return (super.test(value) // 在约定日范围内的某一天
 				//匹配器中用户定义了最后一天（31表示最后一天）
-				|| (value > 27 && match(31) && isLastDayOfMonth(value, month, isLeapYear)));
+				|| (value > 27 && test(31) && isLastDayOfMonth(value, month, isLeapYear)));
 	}
 
 	/**
diff --git a/hutool-cron/src/main/java/cn/hutool/cron/pattern/matcher/PartMatcher.java b/hutool-cron/src/main/java/cn/hutool/cron/pattern/matcher/PartMatcher.java
index 7dcf3248d..bff05f4c8 100755
--- a/hutool-cron/src/main/java/cn/hutool/cron/pattern/matcher/PartMatcher.java
+++ b/hutool-cron/src/main/java/cn/hutool/cron/pattern/matcher/PartMatcher.java
@@ -1,6 +1,6 @@
 package cn.hutool.cron.pattern.matcher;
 
-import cn.hutool.core.lang.func.Matcher;
+import java.util.function.Predicate;
 
 /**
  * 表达式中的某个位置部分匹配器<br>
@@ -8,7 +8,7 @@ import cn.hutool.core.lang.func.Matcher;
  *
  * @author Looly
  */
-public interface PartMatcher extends Matcher<Integer> {
+public interface PartMatcher extends Predicate<Integer> {
 
 	/**
 	 * 获取指定值之后的匹配值，也可以是指定值本身
diff --git a/hutool-cron/src/main/java/cn/hutool/cron/pattern/matcher/PatternMatcher.java b/hutool-cron/src/main/java/cn/hutool/cron/pattern/matcher/PatternMatcher.java
index 7685cb9b5..5d5b2d74c 100755
--- a/hutool-cron/src/main/java/cn/hutool/cron/pattern/matcher/PatternMatcher.java
+++ b/hutool-cron/src/main/java/cn/hutool/cron/pattern/matcher/PatternMatcher.java
@@ -80,7 +80,7 @@ public class PatternMatcher {
 	 * @since 5.8.0
 	 */
 	public boolean matchWeek(final int dayOfWeekValue) {
-		return matchers[5].match(dayOfWeekValue);
+		return matchers[5].test(dayOfWeekValue);
 	}
 
 	/**
@@ -96,13 +96,13 @@ public class PatternMatcher {
 	 * @return 如果匹配返回 {@code true}, 否则返回 {@code false}
 	 */
 	private boolean match(final int second, final int minute, final int hour, final int dayOfMonth, final int month, final int dayOfWeek, final int year) {
-		return ((second < 0) || matchers[0].match(second)) // 匹配秒（非秒匹配模式下始终返回true）
-				&& matchers[1].match(minute)// 匹配分
-				&& matchers[2].match(hour)// 匹配时
+		return ((second < 0) || matchers[0].test(second)) // 匹配秒（非秒匹配模式下始终返回true）
+				&& matchers[1].test(minute)// 匹配分
+				&& matchers[2].test(hour)// 匹配时
 				&& matchDayOfMonth(matchers[3], dayOfMonth, month, Year.isLeap(year))// 匹配日
-				&& matchers[4].match(month) // 匹配月
-				&& matchers[5].match(dayOfWeek)// 匹配周
-				&& matchers[6].match(year);// 匹配年
+				&& matchers[4].test(month) // 匹配月
+				&& matchers[5].test(dayOfWeek)// 匹配周
+				&& matchers[6].test(year);// 匹配年
 	}
 
 	/**
@@ -117,7 +117,7 @@ public class PatternMatcher {
 	private static boolean matchDayOfMonth(final PartMatcher matcher, final int dayOfMonth, final int month, final boolean isLeapYear) {
 		return ((matcher instanceof DayOfMonthMatcher) //
 				? ((DayOfMonthMatcher) matcher).match(dayOfMonth, month, isLeapYear) //
-				: matcher.match(dayOfMonth));
+				: matcher.test(dayOfMonth));
 	}
 	//endregion
 
diff --git a/hutool-cron/src/main/java/cn/hutool/cron/pattern/matcher/YearValueMatcher.java b/hutool-cron/src/main/java/cn/hutool/cron/pattern/matcher/YearValueMatcher.java
index 62b9c585e..45e48e73c 100644
--- a/hutool-cron/src/main/java/cn/hutool/cron/pattern/matcher/YearValueMatcher.java
+++ b/hutool-cron/src/main/java/cn/hutool/cron/pattern/matcher/YearValueMatcher.java
@@ -18,7 +18,7 @@ public class YearValueMatcher implements PartMatcher {
 	}
 
 	@Override
-	public boolean match(final Integer t) {
+	public boolean test(final Integer t) {
 		return valueList.contains(t);
 	}
 
diff --git a/hutool-extra/src/main/java/cn/hutool/extra/compress/archiver/Archiver.java b/hutool-extra/src/main/java/cn/hutool/extra/compress/archiver/Archiver.java
index 11abdab39..4d9af2894 100755
--- a/hutool-extra/src/main/java/cn/hutool/extra/compress/archiver/Archiver.java
+++ b/hutool-extra/src/main/java/cn/hutool/extra/compress/archiver/Archiver.java
@@ -1,10 +1,10 @@
 package cn.hutool.extra.compress.archiver;
 
-import cn.hutool.core.lang.func.Filter;
 import cn.hutool.core.text.StrUtil;
 
 import java.io.Closeable;
 import java.io.File;
+import java.util.function.Predicate;
 
 /**
  * 数据归档封装，归档即将几个文件或目录打成一个压缩包
@@ -27,11 +27,11 @@ public interface Archiver extends Closeable {
 	 * 将文件或目录加入归档，目录采取递归读取方式按照层级加入
 	 *
 	 * @param file   文件或目录
-	 * @param filter 文件过滤器，指定哪些文件或目录可以加入，当{@link Filter#accept(Object)}为true时加入。
+	 * @param predicate 文件过滤器，指定哪些文件或目录可以加入，{@link Predicate#test(Object)}为{@code true}时加入，null表示全部加入
 	 * @return this
 	 */
-	default Archiver add(final File file, final Filter<File> filter) {
-		return add(file, StrUtil.SLASH, filter);
+	default Archiver add(final File file, final Predicate<File> predicate) {
+		return add(file, StrUtil.SLASH, predicate);
 	}
 
 	/**
@@ -39,10 +39,10 @@ public interface Archiver extends Closeable {
 	 *
 	 * @param file   文件或目录
 	 * @param path   文件或目录的初始路径，null表示位于根路径
-	 * @param filter 文件过滤器，指定哪些文件或目录可以加入，当{@link Filter#accept(Object)}为true时加入。
+	 * @param filter 文件过滤器，指定哪些文件或目录可以加入，{@link Predicate#test(Object)}为{@code true}保留，null表示全部加入
 	 * @return this
 	 */
-	Archiver add(File file, String path, Filter<File> filter);
+	Archiver add(File file, String path, Predicate<File> filter);
 
 	/**
 	 * 结束已经增加的文件归档，此方法不会关闭归档流，可以继续添加文件
diff --git a/hutool-extra/src/main/java/cn/hutool/extra/compress/archiver/SevenZArchiver.java b/hutool-extra/src/main/java/cn/hutool/extra/compress/archiver/SevenZArchiver.java
index f1dd3a6bd..2762a5233 100755
--- a/hutool-extra/src/main/java/cn/hutool/extra/compress/archiver/SevenZArchiver.java
+++ b/hutool-extra/src/main/java/cn/hutool/extra/compress/archiver/SevenZArchiver.java
@@ -3,9 +3,8 @@ package cn.hutool.extra.compress.archiver;
 import cn.hutool.core.io.FileUtil;
 import cn.hutool.core.io.IORuntimeException;
 import cn.hutool.core.io.IoUtil;
-import cn.hutool.core.lang.func.Filter;
-import cn.hutool.core.util.ArrayUtil;
 import cn.hutool.core.text.StrUtil;
+import cn.hutool.core.util.ArrayUtil;
 import org.apache.commons.compress.archivers.sevenz.SevenZOutputFile;
 import org.apache.commons.compress.utils.SeekableInMemoryByteChannel;
 
@@ -13,6 +12,7 @@ import java.io.File;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.nio.channels.SeekableByteChannel;
+import java.util.function.Predicate;
 
 /**
  * 7zip格式的归档封装
@@ -77,7 +77,7 @@ public class SevenZArchiver implements Archiver {
 	}
 
 	@Override
-	public SevenZArchiver add(final File file, final String path, final Filter<File> filter) {
+	public SevenZArchiver add(final File file, final String path, final Predicate<File> filter) {
 		try {
 			addInternal(file, path, filter);
 		} catch (final IOException e) {
@@ -118,19 +118,19 @@ public class SevenZArchiver implements Archiver {
 	 *
 	 * @param file   文件或目录
 	 * @param path   文件或目录的初始路径，null表示位于根路径
-	 * @param filter 文件过滤器，指定哪些文件或目录可以加入，当{@link Filter#accept(Object)}为true时加入。
+	 * @param filter 文件过滤器，指定哪些文件或目录可以加入，当{@link Predicate#test(Object)}为{@code true}保留，null表示保留全部
 	 */
-	private void addInternal(final File file, final String path, final Filter<File> filter) throws IOException {
-		if (null != filter && false == filter.accept(file)) {
+	private void addInternal(final File file, final String path, final Predicate<File> filter) throws IOException {
+		if (null != filter && false == filter.test(file)) {
 			return;
 		}
 		final SevenZOutputFile out = this.sevenZOutputFile;
 
 		final String entryName;
-		if(StrUtil.isNotEmpty(path)){
+		if (StrUtil.isNotEmpty(path)) {
 			// 非空拼接路径，格式为：path/name
 			entryName = StrUtil.addSuffixIfNot(path, StrUtil.SLASH) + file.getName();
-		} else{
+		} else {
 			// 路径空直接使用文件名或目录名
 			entryName = file.getName();
 		}
@@ -139,7 +139,7 @@ public class SevenZArchiver implements Archiver {
 		if (file.isDirectory()) {
 			// 目录遍历写入
 			final File[] files = file.listFiles();
-			if(ArrayUtil.isNotEmpty(files)){
+			if (ArrayUtil.isNotEmpty(files)) {
 				for (final File childFile : files) {
 					addInternal(childFile, entryName, filter);
 				}
diff --git a/hutool-extra/src/main/java/cn/hutool/extra/compress/archiver/StreamArchiver.java b/hutool-extra/src/main/java/cn/hutool/extra/compress/archiver/StreamArchiver.java
index bb6f07f71..fbde6e918 100755
--- a/hutool-extra/src/main/java/cn/hutool/extra/compress/archiver/StreamArchiver.java
+++ b/hutool-extra/src/main/java/cn/hutool/extra/compress/archiver/StreamArchiver.java
@@ -3,9 +3,8 @@ package cn.hutool.extra.compress.archiver;
 import cn.hutool.core.io.FileUtil;
 import cn.hutool.core.io.IORuntimeException;
 import cn.hutool.core.io.IoUtil;
-import cn.hutool.core.lang.func.Filter;
-import cn.hutool.core.util.ArrayUtil;
 import cn.hutool.core.text.StrUtil;
+import cn.hutool.core.util.ArrayUtil;
 import cn.hutool.extra.compress.CompressException;
 import org.apache.commons.compress.archivers.ArchiveException;
 import org.apache.commons.compress.archivers.ArchiveOutputStream;
@@ -17,6 +16,7 @@ import java.io.File;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.nio.charset.Charset;
+import java.util.function.Predicate;
 
 /**
  * 数据归档封装，归档即将几个文件或目录打成一个压缩包<br>
@@ -86,26 +86,26 @@ public class StreamArchiver implements Archiver {
 		}
 
 		//特殊设置
-		if(this.out instanceof TarArchiveOutputStream){
-			((TarArchiveOutputStream)out).setLongFileMode(TarArchiveOutputStream.LONGFILE_GNU);
-		} else if(this.out instanceof ArArchiveOutputStream){
-			((ArArchiveOutputStream)out).setLongFileMode(ArArchiveOutputStream.LONGFILE_BSD);
+		if (this.out instanceof TarArchiveOutputStream) {
+			((TarArchiveOutputStream) out).setLongFileMode(TarArchiveOutputStream.LONGFILE_GNU);
+		} else if (this.out instanceof ArArchiveOutputStream) {
+			((ArArchiveOutputStream) out).setLongFileMode(ArArchiveOutputStream.LONGFILE_BSD);
 		}
 	}
 
 	/**
 	 * 将文件或目录加入归档包，目录采取递归读取方式按照层级加入
 	 *
-	 * @param file   文件或目录
-	 * @param path   文件或目录的初始路径，null表示位于根路径
-	 * @param filter 文件过滤器，指定哪些文件或目录可以加入，当{@link Filter#accept(Object)}为true时加入。
+	 * @param file      文件或目录
+	 * @param path      文件或目录的初始路径，null表示位于根路径
+	 * @param predicate 文件过滤器，指定哪些文件或目录可以加入，当{@link Predicate#test(Object)}为{@code true}加入，null表示全部加入
 	 * @return this
 	 * @throws IORuntimeException IO异常
 	 */
 	@Override
-	public StreamArchiver add(final File file, final String path, final Filter<File> filter) throws IORuntimeException {
+	public StreamArchiver add(final File file, final String path, final Predicate<File> predicate) throws IORuntimeException {
 		try {
-			addInternal(file, path, filter);
+			addInternal(file, path, predicate);
 		} catch (final IOException e) {
 			throw new IORuntimeException(e);
 		}
@@ -140,21 +140,21 @@ public class StreamArchiver implements Archiver {
 	/**
 	 * 将文件或目录加入归档包，目录采取递归读取方式按照层级加入
 	 *
-	 * @param file   文件或目录
-	 * @param path   文件或目录的初始路径，{@code null}表示位于根路径
-	 * @param filter 文件过滤器，指定哪些文件或目录可以加入，当{@link Filter#accept(Object)}为true时加入。
+	 * @param file      文件或目录
+	 * @param path      文件或目录的初始路径，{@code null}表示位于根路径
+	 * @param predicate 文件过滤器，指定哪些文件或目录可以加入，当{@link Predicate#test(Object)}为{@code true}加入。
 	 */
-	private void addInternal(final File file, final String path, final Filter<File> filter) throws IOException {
-		if (null != filter && false == filter.accept(file)) {
+	private void addInternal(final File file, final String path, final Predicate<File> predicate) throws IOException {
+		if (null != predicate && false == predicate.test(file)) {
 			return;
 		}
 		final ArchiveOutputStream out = this.out;
 
 		final String entryName;
-		if(StrUtil.isNotEmpty(path)){
+		if (StrUtil.isNotEmpty(path)) {
 			// 非空拼接路径，格式为：path/name
 			entryName = StrUtil.addSuffixIfNot(path, StrUtil.SLASH) + file.getName();
-		} else{
+		} else {
 			// 路径空直接使用文件名或目录名
 			entryName = file.getName();
 		}
@@ -163,9 +163,9 @@ public class StreamArchiver implements Archiver {
 		if (file.isDirectory()) {
 			// 目录遍历写入
 			final File[] files = file.listFiles();
-			if(ArrayUtil.isNotEmpty(files)){
+			if (ArrayUtil.isNotEmpty(files)) {
 				for (final File childFile : files) {
-					addInternal(childFile, entryName, filter);
+					addInternal(childFile, entryName, predicate);
 				}
 			}
 		} else {
diff --git a/hutool-extra/src/main/java/cn/hutool/extra/compress/extractor/Extractor.java b/hutool-extra/src/main/java/cn/hutool/extra/compress/extractor/Extractor.java
index 4c4275402..fb9e0c606 100755
--- a/hutool-extra/src/main/java/cn/hutool/extra/compress/extractor/Extractor.java
+++ b/hutool-extra/src/main/java/cn/hutool/extra/compress/extractor/Extractor.java
@@ -1,10 +1,10 @@
 package cn.hutool.extra.compress.extractor;
 
-import cn.hutool.core.lang.func.Filter;
 import org.apache.commons.compress.archivers.ArchiveEntry;
 
 import java.io.Closeable;
 import java.io.File;
+import java.util.function.Predicate;
 
 /**
  * 归档数据解包封装，用于将zip、tar等包解包为文件
@@ -19,7 +19,7 @@ public interface Extractor extends Closeable {
 	 *
 	 * @param targetDir 目标目录
 	 */
-	default void extract(final File targetDir){
+	default void extract(final File targetDir) {
 		extract(targetDir, null);
 	}
 
@@ -27,9 +27,9 @@ public interface Extractor extends Closeable {
 	 * 释放（解压）到指定目录，结束后自动关闭流，此方法只能调用一次
 	 *
 	 * @param targetDir 目标目录
-	 * @param filter    解压文件过滤器，用于指定需要释放的文件，{@code null}表示不过滤。当{@link Filter#accept(Object)}为true时释放。
+	 * @param predicate 解压文件过滤器，用于指定需要释放的文件，{@code null}表示不过滤。{@link Predicate#test(Object)}为{@code true}时释放。
 	 */
-	void extract(File targetDir, Filter<ArchiveEntry> filter);
+	void extract(File targetDir, Predicate<ArchiveEntry> predicate);
 
 	/**
 	 * 无异常关闭
diff --git a/hutool-extra/src/main/java/cn/hutool/extra/compress/extractor/SevenZExtractor.java b/hutool-extra/src/main/java/cn/hutool/extra/compress/extractor/SevenZExtractor.java
index 2579e43e0..637f326b2 100755
--- a/hutool-extra/src/main/java/cn/hutool/extra/compress/extractor/SevenZExtractor.java
+++ b/hutool-extra/src/main/java/cn/hutool/extra/compress/extractor/SevenZExtractor.java
@@ -4,7 +4,6 @@ import cn.hutool.core.io.FileUtil;
 import cn.hutool.core.io.IORuntimeException;
 import cn.hutool.core.io.IoUtil;
 import cn.hutool.core.lang.Assert;
-import cn.hutool.core.lang.func.Filter;
 import cn.hutool.core.text.StrUtil;
 import org.apache.commons.compress.archivers.ArchiveEntry;
 import org.apache.commons.compress.archivers.sevenz.SevenZArchiveEntry;
@@ -16,6 +15,7 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.nio.channels.SeekableByteChannel;
 import java.util.RandomAccess;
+import java.util.function.Predicate;
 
 /**
  * 7z格式数据解压器，即将归档打包的数据释放
@@ -30,7 +30,7 @@ public class SevenZExtractor implements Extractor, RandomAccess {
 	/**
 	 * 构造
 	 *
-	 * @param file     包文件
+	 * @param file 包文件
 	 */
 	public SevenZExtractor(final File file) {
 		this(file, null);
@@ -53,7 +53,7 @@ public class SevenZExtractor implements Extractor, RandomAccess {
 	/**
 	 * 构造
 	 *
-	 * @param in       包流
+	 * @param in 包流
 	 */
 	public SevenZExtractor(final InputStream in) {
 		this(in, null);
@@ -72,7 +72,7 @@ public class SevenZExtractor implements Extractor, RandomAccess {
 	/**
 	 * 构造
 	 *
-	 * @param channel  {@link SeekableByteChannel}
+	 * @param channel {@link SeekableByteChannel}
 	 */
 	public SevenZExtractor(final SeekableByteChannel channel) {
 		this(channel, null);
@@ -92,16 +92,10 @@ public class SevenZExtractor implements Extractor, RandomAccess {
 		}
 	}
 
-	/**
-	 * 释放（解压）到指定目录，结束后自动关闭流，此方法只能调用一次
-	 *
-	 * @param targetDir 目标目录
-	 * @param filter    解压文件过滤器，用于指定需要释放的文件，null表示不过滤。当{@link Filter#accept(Object)}为true时释放。
-	 */
 	@Override
-	public void extract(final File targetDir, final Filter<ArchiveEntry> filter) {
+	public void extract(final File targetDir, final Predicate<ArchiveEntry> predicate) {
 		try {
-			extractInternal(targetDir, filter);
+			extractInternal(targetDir, predicate);
 		} catch (final IOException e) {
 			throw new IORuntimeException(e);
 		} finally {
@@ -112,17 +106,17 @@ public class SevenZExtractor implements Extractor, RandomAccess {
 	/**
 	 * 获取满足指定过滤要求的压缩包内的第一个文件流
 	 *
-	 * @param filter 用于指定需要释放的文件，null表示不过滤。当{@link Filter#accept(Object)}为true时返回对应流。
-	 * @return 满足过滤要求的第一个文件的流,无满足条件的文件返回{@code null}
+	 * @param predicate 用于指定需要释放的文件，null表示不过滤。当{@link Predicate#test(Object)}为{@code true}返回对应流。
+	 * @return 满足过滤要求的第一个文件的流, 无满足条件的文件返回{@code null}
 	 * @since 5.7.14
 	 */
-	public InputStream getFirst(final Filter<ArchiveEntry> filter) {
+	public InputStream getFirst(final Predicate<ArchiveEntry> predicate) {
 		final SevenZFile sevenZFile = this.sevenZFile;
-		for(final SevenZArchiveEntry entry : sevenZFile.getEntries()){
-			if(null != filter && false == filter.accept(entry)){
+		for (final SevenZArchiveEntry entry : sevenZFile.getEntries()) {
+			if (null != predicate && false == predicate.test(entry)) {
 				continue;
 			}
-			if(entry.isDirectory()){
+			if (entry.isDirectory()) {
 				continue;
 			}
 
@@ -143,24 +137,24 @@ public class SevenZExtractor implements Extractor, RandomAccess {
 	 * @return 文件流，无文件返回{@code null}
 	 * @since 5.7.14
 	 */
-	public InputStream get(final String entryName){
-		return getFirst((entry)-> StrUtil.equals(entryName, entry.getName()));
+	public InputStream get(final String entryName) {
+		return getFirst((entry) -> StrUtil.equals(entryName, entry.getName()));
 	}
 
 	/**
 	 * 释放（解压）到指定目录
 	 *
 	 * @param targetDir 目标目录
-	 * @param filter    解压文件过滤器，用于指定需要释放的文件，null表示不过滤。当{@link Filter#accept(Object)}为true时释放。
+	 * @param predicate 解压文件过滤器，用于指定需要释放的文件，null表示不过滤。当{@link Predicate#test(Object)}为{@code true}时释放。
 	 * @throws IOException IO异常
 	 */
-	private void extractInternal(final File targetDir, final Filter<ArchiveEntry> filter) throws IOException {
+	private void extractInternal(final File targetDir, final Predicate<ArchiveEntry> predicate) throws IOException {
 		Assert.isTrue(null != targetDir && ((false == targetDir.exists()) || targetDir.isDirectory()), "target must be dir.");
 		final SevenZFile sevenZFile = this.sevenZFile;
 		SevenZArchiveEntry entry;
 		File outItemFile;
 		while (null != (entry = this.sevenZFile.getNextEntry())) {
-			if(null != filter && false == filter.accept(entry)){
+			if (null != predicate && false == predicate.test(entry)) {
 				continue;
 			}
 			outItemFile = FileUtil.file(targetDir, entry.getName());
@@ -168,7 +162,7 @@ public class SevenZExtractor implements Extractor, RandomAccess {
 				// 创建对应目录
 				//noinspection ResultOfMethodCallIgnored
 				outItemFile.mkdirs();
-			} else if(entry.hasStream()){
+			} else if (entry.hasStream()) {
 				// 读取entry对应数据流
 				FileUtil.writeFromStream(new Seven7EntryInputStream(sevenZFile, entry), outItemFile);
 			} else {
diff --git a/hutool-extra/src/main/java/cn/hutool/extra/compress/extractor/StreamExtractor.java b/hutool-extra/src/main/java/cn/hutool/extra/compress/extractor/StreamExtractor.java
index 782ce5314..05fd60af6 100755
--- a/hutool-extra/src/main/java/cn/hutool/extra/compress/extractor/StreamExtractor.java
+++ b/hutool-extra/src/main/java/cn/hutool/extra/compress/extractor/StreamExtractor.java
@@ -4,7 +4,6 @@ import cn.hutool.core.io.FileUtil;
 import cn.hutool.core.io.IORuntimeException;
 import cn.hutool.core.io.IoUtil;
 import cn.hutool.core.lang.Assert;
-import cn.hutool.core.lang.func.Filter;
 import cn.hutool.core.text.StrUtil;
 import cn.hutool.extra.compress.CompressException;
 import org.apache.commons.compress.archivers.ArchiveEntry;
@@ -16,6 +15,7 @@ import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.charset.Charset;
+import java.util.function.Predicate;
 
 /**
  * 数据解压器，即将归档打包的数据释放
@@ -23,15 +23,15 @@ import java.nio.charset.Charset;
  * @author looly
  * @since 5.5.0
  */
-public class StreamExtractor implements Extractor{
+public class StreamExtractor implements Extractor {
 
 	private final ArchiveInputStream in;
 
 	/**
 	 * 构造
 	 *
-	 * @param charset      编码
-	 * @param file         包文件
+	 * @param charset 编码
+	 * @param file    包文件
 	 */
 	public StreamExtractor(final Charset charset, final File file) {
 		this(charset, null, file);
@@ -85,12 +85,12 @@ public class StreamExtractor implements Extractor{
 	 * 释放（解压）到指定目录，结束后自动关闭流，此方法只能调用一次
 	 *
 	 * @param targetDir 目标目录
-	 * @param filter    解压文件过滤器，用于指定需要释放的文件，null表示不过滤。当{@link Filter#accept(Object)}为true时释放。
+	 * @param predicate 解压文件过滤器，用于指定需要释放的文件，null表示不过滤。当{@link Predicate#test(Object)}为{@code true}时释放。
 	 */
 	@Override
-	public void extract(final File targetDir, final Filter<ArchiveEntry> filter) {
+	public void extract(final File targetDir, final Predicate<ArchiveEntry> predicate) {
 		try {
-			extractInternal(targetDir, filter);
+			extractInternal(targetDir, predicate);
 		} catch (final IOException e) {
 			throw new IORuntimeException(e);
 		} finally {
@@ -102,16 +102,16 @@ public class StreamExtractor implements Extractor{
 	 * 释放（解压）到指定目录
 	 *
 	 * @param targetDir 目标目录
-	 * @param filter    解压文件过滤器，用于指定需要释放的文件，null表示不过滤。当{@link Filter#accept(Object)}为true时释放。
+	 * @param predicate 解压文件过滤器，用于指定需要释放的文件，null表示不过滤。当{@link Predicate#test(Object)}为{@code true}释放。
 	 * @throws IOException IO异常
 	 */
-	private void extractInternal(final File targetDir, final Filter<ArchiveEntry> filter) throws IOException {
+	private void extractInternal(final File targetDir, final Predicate<ArchiveEntry> predicate) throws IOException {
 		Assert.isTrue(null != targetDir && ((false == targetDir.exists()) || targetDir.isDirectory()), "target must be dir.");
 		final ArchiveInputStream in = this.in;
 		ArchiveEntry entry;
 		File outItemFile;
 		while (null != (entry = in.getNextEntry())) {
-			if(null != filter && false == filter.accept(entry)){
+			if (null != predicate && false == predicate.test(entry)) {
 				continue;
 			}
 			if (false == in.canReadEntryData(entry)) {
diff --git a/hutool-extra/src/main/java/cn/hutool/extra/ftp/Ftp.java b/hutool-extra/src/main/java/cn/hutool/extra/ftp/Ftp.java
index 8deffd66d..65bf446c8 100755
--- a/hutool-extra/src/main/java/cn/hutool/extra/ftp/Ftp.java
+++ b/hutool-extra/src/main/java/cn/hutool/extra/ftp/Ftp.java
@@ -4,10 +4,9 @@ import cn.hutool.core.collection.ListUtil;
 import cn.hutool.core.io.FileUtil;
 import cn.hutool.core.io.IORuntimeException;
 import cn.hutool.core.lang.Assert;
-import cn.hutool.core.lang.func.Filter;
+import cn.hutool.core.text.StrUtil;
 import cn.hutool.core.util.ArrayUtil;
 import cn.hutool.core.util.CharsetUtil;
-import cn.hutool.core.text.StrUtil;
 import org.apache.commons.net.ftp.FTPClient;
 import org.apache.commons.net.ftp.FTPClientConfig;
 import org.apache.commons.net.ftp.FTPFile;
@@ -21,6 +20,7 @@ import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.Predicate;
 
 /**
  * FTP客户端封装<br>
@@ -340,11 +340,11 @@ public class Ftp extends AbstractFtp {
 	 * 此方法自动过滤"."和".."两种目录
 	 *
 	 * @param path   目录
-	 * @param filter 过滤器，null表示不过滤，默认去掉"."和".."两种目录
+	 * @param predicate 过滤器，null表示不过滤，默认去掉"."和".."两种目录
 	 * @return 文件或目录列表
 	 * @since 5.3.5
 	 */
-	public List<FTPFile> lsFiles(final String path, final Filter<FTPFile> filter) {
+	public List<FTPFile> lsFiles(final String path, final Predicate<FTPFile> predicate) {
 		final FTPFile[] ftpFiles = lsFiles(path);
 		if (ArrayUtil.isEmpty(ftpFiles)) {
 			return ListUtil.empty();
@@ -355,7 +355,7 @@ public class Ftp extends AbstractFtp {
 		for (final FTPFile ftpFile : ftpFiles) {
 			fileName = ftpFile.getName();
 			if (false == StrUtil.equals(".", fileName) && false == StrUtil.equals("..", fileName)) {
-				if (null == filter || filter.accept(ftpFile)) {
+				if (null == predicate || predicate.test(ftpFile)) {
 					result.add(ftpFile);
 				}
 			}
diff --git a/hutool-extra/src/main/java/cn/hutool/extra/ssh/Sftp.java b/hutool-extra/src/main/java/cn/hutool/extra/ssh/Sftp.java
index 6bdc57f9c..6e4008f0d 100755
--- a/hutool-extra/src/main/java/cn/hutool/extra/ssh/Sftp.java
+++ b/hutool-extra/src/main/java/cn/hutool/extra/ssh/Sftp.java
@@ -3,7 +3,6 @@ package cn.hutool.extra.ssh;
 import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.collection.ListUtil;
 import cn.hutool.core.io.FileUtil;
-import cn.hutool.core.lang.func.Filter;
 import cn.hutool.core.text.StrUtil;
 import cn.hutool.extra.ftp.AbstractFtp;
 import cn.hutool.extra.ftp.FtpConfig;
@@ -23,6 +22,7 @@ import java.nio.charset.Charset;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Vector;
+import java.util.function.Predicate;
 
 /**
  * SFTP是Secure File Transfer Protocol的缩写，安全文件传送协议。可以为传输文件提供一种安全的加密方法。<br>
@@ -302,13 +302,13 @@ public class Sftp extends AbstractFtp {
 	 * 遍历某个目录下所有文件或目录，不会递归遍历<br>
 	 * 此方法自动过滤"."和".."两种目录
 	 *
-	 * @param path   遍历某个目录下所有文件或目录
-	 * @param filter 文件或目录过滤器，可以实现过滤器返回自己需要的文件或目录名列表
+	 * @param path      遍历某个目录下所有文件或目录
+	 * @param predicate 文件或目录过滤器，可以实现过滤器返回自己需要的文件或目录名列表，{@link Predicate#test(Object)}为{@code true}保留
 	 * @return 目录或文件名列表
 	 * @since 4.0.5
 	 */
-	public List<String> ls(final String path, final Filter<LsEntry> filter) {
-		final List<LsEntry> entries = lsEntries(path, filter);
+	public List<String> ls(final String path, final Predicate<LsEntry> predicate) {
+		final List<LsEntry> entries = lsEntries(path, predicate);
 		if (CollUtil.isEmpty(entries)) {
 			return ListUtil.empty();
 		}
@@ -331,18 +331,18 @@ public class Sftp extends AbstractFtp {
 	 * 遍历某个目录下所有文件或目录，生成LsEntry列表，不会递归遍历<br>
 	 * 此方法自动过滤"."和".."两种目录
 	 *
-	 * @param path   遍历某个目录下所有文件或目录
-	 * @param filter 文件或目录过滤器，可以实现过滤器返回自己需要的文件或目录名列表
+	 * @param path      遍历某个目录下所有文件或目录
+	 * @param predicate 文件或目录过滤器，可以实现过滤器返回自己需要的文件或目录名列表，{@link Predicate#test(Object)}为{@code true}保留
 	 * @return 目录或文件名列表
 	 * @since 5.3.5
 	 */
-	public List<LsEntry> lsEntries(final String path, final Filter<LsEntry> filter) {
+	public List<LsEntry> lsEntries(final String path, final Predicate<LsEntry> predicate) {
 		final List<LsEntry> entryList = new ArrayList<>();
 		try {
 			channel.ls(path, entry -> {
 				final String fileName = entry.getFilename();
 				if (false == StrUtil.equals(".", fileName) && false == StrUtil.equals("..", fileName)) {
-					if (null == filter || filter.accept(entry)) {
+					if (null == predicate || predicate.test(entry)) {
 						entryList.add(entry);
 					}
 				}
diff --git a/hutool-json/src/main/java/cn/hutool/json/InternalJSONUtil.java b/hutool-json/src/main/java/cn/hutool/json/InternalJSONUtil.java
index 869118446..3abf398e7 100755
--- a/hutool-json/src/main/java/cn/hutool/json/InternalJSONUtil.java
+++ b/hutool-json/src/main/java/cn/hutool/json/InternalJSONUtil.java
@@ -2,15 +2,14 @@ package cn.hutool.json;
 
 import cn.hutool.core.bean.copier.CopyOptions;
 import cn.hutool.core.convert.Convert;
-import cn.hutool.core.lang.func.Filter;
 import cn.hutool.core.lang.mutable.MutableEntry;
 import cn.hutool.core.map.CaseInsensitiveLinkedMap;
 import cn.hutool.core.map.CaseInsensitiveTreeMap;
+import cn.hutool.core.math.NumberUtil;
+import cn.hutool.core.text.StrUtil;
 import cn.hutool.core.util.ArrayUtil;
 import cn.hutool.core.util.CharUtil;
-import cn.hutool.core.math.NumberUtil;
 import cn.hutool.core.util.ObjUtil;
-import cn.hutool.core.text.StrUtil;
 
 import java.math.BigDecimal;
 import java.util.Collection;
@@ -18,6 +17,7 @@ import java.util.Comparator;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.TreeMap;
+import java.util.function.Predicate;
 
 /**
  * 内部JSON工具类，仅用于JSON内部使用
@@ -138,9 +138,10 @@ public final class InternalJSONUtil {
 	 * @param jsonObject JSONObject
 	 * @param key        键
 	 * @param value      值
+	 * @param predicate  属性过滤器，{@link Predicate#test(Object)}为{@code true}保留
 	 * @return JSONObject
 	 */
-	static JSONObject propertyPut(final JSONObject jsonObject, final Object key, final Object value, final Filter<MutableEntry<String, Object>> filter) {
+	static JSONObject propertyPut(final JSONObject jsonObject, final Object key, final Object value, final Predicate<MutableEntry<String, Object>> predicate) {
 		final String[] path = StrUtil.splitToArray(Convert.toStr(key), CharUtil.DOT);
 		final int last = path.length - 1;
 		JSONObject target = jsonObject;
@@ -149,11 +150,11 @@ public final class InternalJSONUtil {
 			JSONObject nextTarget = target.getJSONObject(segment);
 			if (nextTarget == null) {
 				nextTarget = new JSONObject(target.getConfig());
-				target.setOnce(segment, nextTarget, filter);
+				target.setOnce(segment, nextTarget, predicate);
 			}
 			target = nextTarget;
 		}
-		target.setOnce(path[last], value, filter);
+		target.setOnce(path[last], value, predicate);
 		return jsonObject;
 	}
 
diff --git a/hutool-json/src/main/java/cn/hutool/json/JSONArray.java b/hutool-json/src/main/java/cn/hutool/json/JSONArray.java
index a7cd482f0..a3adef91c 100755
--- a/hutool-json/src/main/java/cn/hutool/json/JSONArray.java
+++ b/hutool-json/src/main/java/cn/hutool/json/JSONArray.java
@@ -3,7 +3,6 @@ package cn.hutool.json;
 import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.convert.Convert;
 import cn.hutool.core.convert.impl.ArrayConverter;
-import cn.hutool.core.lang.func.Filter;
 import cn.hutool.core.lang.mutable.Mutable;
 import cn.hutool.core.lang.mutable.MutableEntry;
 import cn.hutool.core.lang.mutable.MutableObj;
@@ -20,6 +19,7 @@ import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
 import java.util.RandomAccess;
+import java.util.function.Predicate;
 
 /**
  * JSON数组<br>
@@ -142,13 +142,13 @@ public class JSONArray implements JSON, JSONGetter<Integer>, List<Object>, Rando
 	 *
 	 * @param object     数组或集合或JSON数组字符串
 	 * @param jsonConfig JSON选项
-	 * @param filter     键值对过滤编辑器，可以通过实现此接口，完成解析前对值的过滤和修改操作，{@code null}表示不过滤
+	 * @param predicate  键值对过滤编辑器，可以通过实现此接口，完成解析前对值的过滤和修改操作，{@code null}表示不过滤，{@link Predicate#test(Object)}为{@code true}保留
 	 * @throws JSONException 非数组或集合
 	 * @since 5.8.0
 	 */
-	public JSONArray(final Object object, final JSONConfig jsonConfig, final Filter<Mutable<Object>> filter) throws JSONException {
+	public JSONArray(final Object object, final JSONConfig jsonConfig, final Predicate<Mutable<Object>> predicate) throws JSONException {
 		this(DEFAULT_CAPACITY, jsonConfig);
-		ObjectMapper.of(object).map(this, filter);
+		ObjectMapper.of(object).map(this, predicate);
 	}
 	// endregion
 
@@ -365,7 +365,7 @@ public class JSONArray implements JSON, JSONGetter<Integer>, List<Object>, Rando
 		}
 		final ArrayList<Object> list = new ArrayList<>(c.size());
 		for (final Object object : c) {
-			if(null == object && config.isIgnoreNullValue()){
+			if (null == object && config.isIgnoreNullValue()) {
 				continue;
 			}
 			this.add(index);
@@ -407,15 +407,15 @@ public class JSONArray implements JSON, JSONGetter<Integer>, List<Object>, Rando
 	 *
 	 * @param index   位置
 	 * @param element 值对象. 可以是以下类型: Boolean, Double, Integer, JSONArray, JSONObject, Long, String, or the JSONNull.NULL.
-	 * @param filter  过滤器，可以修改值，key（index）无法修改
+	 * @param filter  过滤器，可以修改值，key（index）无法修改，{@link Predicate#test(Object)}为{@code true}保留，null表示全部保留。
 	 * @return 替换的值，即之前的值
 	 * @since 5.8.0
 	 */
-	public Object set(final int index, Object element, final Filter<MutableEntry<Integer, Object>> filter) {
+	public Object set(final int index, Object element, final Predicate<MutableEntry<Integer, Object>> filter) {
 		// 添加前置过滤，通过MutablePair实现过滤、修改键值对等
 		if (null != filter) {
 			final MutableEntry<Integer, Object> pair = new MutableEntry<>(index, element);
-			if (filter.accept(pair)) {
+			if (filter.test(pair)) {
 				// 使用修改后的值
 				element = pair.getValue();
 			}
@@ -426,7 +426,7 @@ public class JSONArray implements JSON, JSONGetter<Integer>, List<Object>, Rando
 			add(index, element);
 			return null;
 		}
-		if(null == element && config.isIgnoreNullValue()){
+		if (null == element && config.isIgnoreNullValue()) {
 			return null;
 		}
 		return this.rawList.set(index, JSONUtil.wrap(element, this.config));
@@ -434,7 +434,7 @@ public class JSONArray implements JSON, JSONGetter<Integer>, List<Object>, Rando
 
 	@Override
 	public void add(int index, final Object element) {
-		if(null == element && config.isIgnoreNullValue()){
+		if (null == element && config.isIgnoreNullValue()) {
 			return;
 		}
 		if (index < this.size()) {
@@ -444,7 +444,7 @@ public class JSONArray implements JSON, JSONGetter<Integer>, List<Object>, Rando
 			InternalJSONUtil.testValidity(element);
 			this.rawList.add(index, JSONUtil.wrap(element, this.config));
 		} else {
-			if(false == config.isIgnoreNullValue()){
+			if (false == config.isIgnoreNullValue()) {
 				while (index != this.size()) {
 					// 非末尾，则填充null
 					this.add(null);
@@ -517,14 +517,14 @@ public class JSONArray implements JSON, JSONGetter<Integer>, List<Object>, Rando
 	 * 支持过滤器，即选择哪些字段或值不写出
 	 *
 	 * @param indentFactor 每层缩进空格数
-	 * @param filter       过滤器，可以修改值，key（index）无法修改
+	 * @param predicate    过滤器，可以修改值，key（index）无法修改，{@link Predicate#test(Object)}为{@code true}保留
 	 * @return JSON字符串
 	 * @since 5.7.15
 	 */
-	public String toJSONString(final int indentFactor, final Filter<MutableEntry<Integer, Object>> filter) {
+	public String toJSONString(final int indentFactor, final Predicate<MutableEntry<Integer, Object>> predicate) {
 		final StringWriter sw = new StringWriter();
 		synchronized (sw.getBuffer()) {
-			return this.write(sw, indentFactor, 0, filter).toString();
+			return this.write(sw, indentFactor, 0, predicate).toString();
 		}
 	}
 
@@ -540,18 +540,18 @@ public class JSONArray implements JSON, JSONGetter<Integer>, List<Object>, Rando
 	 * @param writer       writer
 	 * @param indentFactor 缩进因子，定义每一级别增加的缩进量
 	 * @param indent       本级别缩进量
-	 * @param filter       过滤器，可以修改值，key（index）无法修改
+	 * @param predicate    过滤器，可以修改值，key（index）无法修改，{@link Predicate#test(Object)}为{@code true}保留
 	 * @return Writer
 	 * @throws JSONException JSON相关异常
 	 * @since 5.7.15
 	 */
-	public Writer write(final Writer writer, final int indentFactor, final int indent, final Filter<MutableEntry<Integer, Object>> filter) throws JSONException {
+	public Writer write(final Writer writer, final int indentFactor, final int indent, final Predicate<MutableEntry<Integer, Object>> predicate) throws JSONException {
 		final JSONWriter jsonWriter = JSONWriter.of(writer, indentFactor, indent, config)
 				.beginArray();
 
 		CollUtil.forEach(this, (value, index) -> {
 			final MutableEntry<Integer, Object> pair = new MutableEntry<>(index, value);
-			if (null == filter || filter.accept(pair)) {
+			if (null == predicate || predicate.test(pair)) {
 				jsonWriter.writeValue(pair.getValue());
 			}
 		});
@@ -570,24 +570,24 @@ public class JSONArray implements JSON, JSONGetter<Integer>, List<Object>, Rando
 	/**
 	 * 原始添加，添加的对象不做任何处理
 	 *
-	 * @param obj    添加的对象
-	 * @param filter 键值对过滤编辑器，可以通过实现此接口，完成解析前对值的过滤和修改操作，{@code null}表示不过滤
+	 * @param obj       添加的对象
+	 * @param predicate 键值对过滤编辑器，可以通过实现此接口，完成解析前对值的过滤和修改操作，{@code null}表示不过滤，{@link Predicate#test(Object)}为{@code true}保留
 	 * @return 是否加入成功
 	 * @since 5.8.0
 	 */
-	protected boolean addRaw(Object obj, final Filter<Mutable<Object>> filter) {
+	protected boolean addRaw(Object obj, final Predicate<Mutable<Object>> predicate) {
 		// 添加前置过滤，通过MutablePair实现过滤、修改键值对等
-		if (null != filter) {
+		if (null != predicate) {
 			final Mutable<Object> mutable = new MutableObj<>(obj);
-			if (filter.accept(mutable)) {
+			if (predicate.test(mutable)) {
 				// 使用修改后的值
 				obj = mutable.get();
-			}else{
+			} else {
 				// 键值对被过滤
 				return false;
 			}
 		}
-		if(null == obj && config.isIgnoreNullValue()){
+		if (null == obj && config.isIgnoreNullValue()) {
 			// 忽略空则不添加
 			return false;
 		}
diff --git a/hutool-json/src/main/java/cn/hutool/json/JSONObject.java b/hutool-json/src/main/java/cn/hutool/json/JSONObject.java
index 7db6f17a8..74e399b30 100755
--- a/hutool-json/src/main/java/cn/hutool/json/JSONObject.java
+++ b/hutool-json/src/main/java/cn/hutool/json/JSONObject.java
@@ -1,7 +1,6 @@
 package cn.hutool.json;
 
 import cn.hutool.core.collection.CollUtil;
-import cn.hutool.core.lang.func.Filter;
 import cn.hutool.core.lang.mutable.MutableEntry;
 import cn.hutool.core.map.MapUtil;
 import cn.hutool.core.map.MapWrapper;
@@ -15,6 +14,7 @@ import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.util.Collection;
 import java.util.Map;
+import java.util.function.Predicate;
 
 /**
  * JSON对象<br>
@@ -120,14 +120,14 @@ public class JSONObject extends MapWrapper<String, Object> implements JSON, JSON
 	 * 如果为普通的JavaBean，调用其getters方法（getXXX或者isXXX）获得值，加入到JSON对象<br>
 	 * 例如：如果JavaBean对象中有个方法getName()，值为"张三"，获得的键值对为：name: "张三"
 	 *
-	 * @param source JavaBean或者Map对象或者String
-	 * @param config JSON配置文件，{@code null}则使用默认配置
-	 * @param filter 键值对过滤编辑器，可以通过实现此接口，完成解析前对键值对的过滤和修改操作，{@code null}表示不过滤
+	 * @param source    JavaBean或者Map对象或者String
+	 * @param config    JSON配置文件，{@code null}则使用默认配置
+	 * @param predicate 键值对过滤编辑器，可以通过实现此接口，完成解析前对键值对的过滤和修改操作，{@code null}表示不过滤，{@link Predicate#test(Object)}为{@code true}保留
 	 * @since 5.8.0
 	 */
-	public JSONObject(final Object source, final JSONConfig config, final Filter<MutableEntry<String, Object>> filter) {
+	public JSONObject(final Object source, final JSONConfig config, final Predicate<MutableEntry<String, Object>> predicate) {
 		this(DEFAULT_CAPACITY, config);
-		ObjectMapper.of(source).map(this, filter);
+		ObjectMapper.of(source).map(this, predicate);
 	}
 	// -------------------------------------------------------------------------------------------------------------------- Constructor end
 
@@ -215,15 +215,15 @@ public class JSONObject extends MapWrapper<String, Object> implements JSON, JSON
 	/**
 	 * 一次性Put 键值对，如果key已经存在抛出异常，如果键值中有null值，忽略
 	 *
-	 * @param key    键
-	 * @param value  值对象，可以是以下类型: Boolean, Double, Integer, JSONArray, JSONObject, Long, String, or the JSONNull.NULL.
-	 * @param filter 键值对过滤编辑器，可以通过实现此接口，完成解析前对键值对的过滤和修改操作，{@code null}表示不过滤
+	 * @param key       键
+	 * @param value     值对象，可以是以下类型: Boolean, Double, Integer, JSONArray, JSONObject, Long, String, or the JSONNull.NULL.
+	 * @param predicate 键值对过滤编辑器，可以通过实现此接口，完成解析前对键值对的过滤和修改操作，{@code null}表示不过滤，{@link Predicate#test(Object)}为{@code true}保留
 	 * @return this
 	 * @throws JSONException 值是无穷数字、键重复抛出异常
 	 * @since 5.8.0
 	 */
-	public JSONObject setOnce(final String key, final Object value, final Filter<MutableEntry<String, Object>> filter) throws JSONException {
-		put(key, value, filter, true);
+	public JSONObject setOnce(final String key, final Object value, final Predicate<MutableEntry<String, Object>> predicate) throws JSONException {
+		put(key, value, predicate, true);
 		return this;
 	}
 
@@ -232,14 +232,14 @@ public class JSONObject extends MapWrapper<String, Object> implements JSON, JSON
 	 *
 	 * @param key            键
 	 * @param value          值对象. 可以是以下类型: Boolean, Double, Integer, JSONArray, JSONObject, Long, String, or the JSONNull.NULL.
-	 * @param filter         键值对过滤编辑器，可以通过实现此接口，完成解析前对键值对的过滤和修改操作，{@code null}表示不过滤
+	 * @param predicate      键值对过滤编辑器，可以通过实现此接口，完成解析前对键值对的过滤和修改操作，{@code null}表示不过滤，{@link Predicate#test(Object)}为{@code true}保留
 	 * @param checkDuplicate 是否检查重复键，如果为{@code true}，则出现重复键时抛出{@link JSONException}异常
 	 * @return this.
 	 * @throws JSONException 值是无穷数字抛出此异常
 	 * @since 5.8.0
 	 */
-	public JSONObject set(final String key, final Object value, final Filter<MutableEntry<String, Object>> filter, final boolean checkDuplicate) throws JSONException {
-		put(key, value, filter, checkDuplicate);
+	public JSONObject set(final String key, final Object value, final Predicate<MutableEntry<String, Object>> predicate, final boolean checkDuplicate) throws JSONException {
+		put(key, value, predicate, checkDuplicate);
 		return this;
 	}
 
@@ -336,14 +336,14 @@ public class JSONObject extends MapWrapper<String, Object> implements JSON, JSON
 	 * 支持过滤器，即选择哪些字段或值不写出
 	 *
 	 * @param indentFactor 每层缩进空格数
-	 * @param filter       过滤器，同时可以修改编辑键和值
+	 * @param predicate    过滤器，同时可以修改编辑键和值，{@link Predicate#test(Object)}为{@code true}保留
 	 * @return JSON字符串
 	 * @since 5.7.15
 	 */
-	public String toJSONString(final int indentFactor, final Filter<MutableEntry<String, Object>> filter) {
+	public String toJSONString(final int indentFactor, final Predicate<MutableEntry<String, Object>> predicate) {
 		final StringWriter sw = new StringWriter();
 		synchronized (sw.getBuffer()) {
-			return this.write(sw, indentFactor, 0, filter).toString();
+			return this.write(sw, indentFactor, 0, predicate).toString();
 		}
 	}
 
@@ -359,18 +359,18 @@ public class JSONObject extends MapWrapper<String, Object> implements JSON, JSON
 	 * @param writer       writer
 	 * @param indentFactor 缩进因子，定义每一级别增加的缩进量
 	 * @param indent       本级别缩进量
-	 * @param filter       过滤器，同时可以修改编辑键和值
+	 * @param predicate    过滤器，同时可以修改编辑键和值
 	 * @return Writer
 	 * @throws JSONException JSON相关异常
 	 * @since 5.7.15
 	 */
-	public Writer write(final Writer writer, final int indentFactor, final int indent, final Filter<MutableEntry<String, Object>> filter) throws JSONException {
+	public Writer write(final Writer writer, final int indentFactor, final int indent, final Predicate<MutableEntry<String, Object>> predicate) throws JSONException {
 		final JSONWriter jsonWriter = JSONWriter.of(writer, indentFactor, indent, config)
 				.beginObj();
 		this.forEach((key, value) -> {
-			if (null != filter) {
+			if (null != predicate) {
 				final MutableEntry<String, Object> pair = new MutableEntry<>(key, value);
-				if (filter.accept(pair)) {
+				if (predicate.test(pair)) {
 					// 使用修改后的键值对
 					jsonWriter.writeField(pair.getKey(), pair.getValue());
 				}
@@ -395,21 +395,21 @@ public class JSONObject extends MapWrapper<String, Object> implements JSON, JSON
 	 *
 	 * @param key            键
 	 * @param value          值对象. 可以是以下类型: Boolean, Double, Integer, JSONArray, JSONObject, Long, String, or the JSONNull.NULL.
-	 * @param filter         键值对过滤编辑器，可以通过实现此接口，完成解析前对键值对的过滤和修改操作，{@code null}表示不过滤
+	 * @param predicate      键值对过滤编辑器，可以通过实现此接口，完成解析前对键值对的过滤和修改操作，{@code null}表示不过滤，{@link Predicate#test(Object)}为{@code true}保留
 	 * @param checkDuplicate 是否检查重复键，如果为{@code true}，则出现重复键时抛出{@link JSONException}异常
 	 * @return 旧值
 	 * @throws JSONException 值是无穷数字抛出此异常
 	 * @since 5.8.0
 	 */
-	private Object put(String key, Object value, final Filter<MutableEntry<String, Object>> filter, final boolean checkDuplicate) throws JSONException {
+	private Object put(String key, Object value, final Predicate<MutableEntry<String, Object>> predicate, final boolean checkDuplicate) throws JSONException {
 		if (null == key) {
 			return null;
 		}
 
 		// 添加前置过滤，通过MutablePair实现过滤、修改键值对等
-		if (null != filter) {
+		if (null != predicate) {
 			final MutableEntry<String, Object> pair = new MutableEntry<>(key, value);
-			if (filter.accept(pair)) {
+			if (predicate.test(pair)) {
 				// 使用修改后的键值对
 				key = pair.getKey();
 				value = pair.getValue();
diff --git a/hutool-json/src/main/java/cn/hutool/json/JSONParser.java b/hutool-json/src/main/java/cn/hutool/json/JSONParser.java
index 2788bce86..ef1f511f8 100755
--- a/hutool-json/src/main/java/cn/hutool/json/JSONParser.java
+++ b/hutool-json/src/main/java/cn/hutool/json/JSONParser.java
@@ -1,9 +1,10 @@
 package cn.hutool.json;
 
-import cn.hutool.core.lang.func.Filter;
 import cn.hutool.core.lang.mutable.Mutable;
 import cn.hutool.core.lang.mutable.MutableEntry;
 
+import java.util.function.Predicate;
+
 /**
  * JSON字符串解析器
  *
@@ -39,9 +40,9 @@ public class JSONParser {
 	 * 解析{@link JSONTokener}中的字符到目标的{@link JSONObject}中
 	 *
 	 * @param jsonObject {@link JSONObject}
-	 * @param filter     键值对过滤编辑器，可以通过实现此接口，完成解析前对键值对的过滤和修改操作，{@code null}表示不过滤
+	 * @param predicate  键值对过滤编辑器，可以通过实现此接口，完成解析前对键值对的过滤和修改操作，{@code null}表示不过滤，{@link Predicate#test(Object)}为{@code true}保留
 	 */
-	public void parseTo(final JSONObject jsonObject, final Filter<MutableEntry<String, Object>> filter) {
+	public void parseTo(final JSONObject jsonObject, final Predicate<MutableEntry<String, Object>> predicate) {
 		final JSONTokener tokener = this.tokener;
 
 		char c;
@@ -69,7 +70,7 @@ public class JSONParser {
 				throw tokener.syntaxError("Expected a ':' after a key");
 			}
 
-			jsonObject.setOnce(key, tokener.nextValue(), filter);
+			jsonObject.setOnce(key, tokener.nextValue(), predicate);
 
 			// Pairs are separated by ','.
 
@@ -95,9 +96,9 @@ public class JSONParser {
 	 * 解析JSON字符串到{@link JSONArray}中
 	 *
 	 * @param jsonArray {@link JSONArray}
-	 * @param filter    键值对过滤编辑器，可以通过实现此接口，完成解析前对值的过滤和修改操作，{@code null} 表示不过滤
+	 * @param predicate 键值对过滤编辑器，可以通过实现此接口，完成解析前对值的过滤和修改操作，{@code null} 表示不过滤，，{@link Predicate#test(Object)}为{@code true}保留
 	 */
-	public void parseTo(final JSONArray jsonArray, final Filter<Mutable<Object>> filter) {
+	public void parseTo(final JSONArray jsonArray, final Predicate<Mutable<Object>> predicate) {
 		final JSONTokener x = this.tokener;
 
 		if (x.nextClean() != '[') {
@@ -108,10 +109,10 @@ public class JSONParser {
 			for (; ; ) {
 				if (x.nextClean() == ',') {
 					x.back();
-					jsonArray.addRaw(null, filter);
+					jsonArray.addRaw(null, predicate);
 				} else {
 					x.back();
-					jsonArray.addRaw(x.nextValue(), filter);
+					jsonArray.addRaw(x.nextValue(), predicate);
 				}
 				switch (x.nextClean()) {
 					case ',':
diff --git a/hutool-json/src/main/java/cn/hutool/json/ObjectMapper.java b/hutool-json/src/main/java/cn/hutool/json/ObjectMapper.java
index 359ae57e9..10e5f1baf 100755
--- a/hutool-json/src/main/java/cn/hutool/json/ObjectMapper.java
+++ b/hutool-json/src/main/java/cn/hutool/json/ObjectMapper.java
@@ -5,12 +5,11 @@ import cn.hutool.core.bean.copier.CopyOptions;
 import cn.hutool.core.collection.iter.ArrayIter;
 import cn.hutool.core.convert.Convert;
 import cn.hutool.core.io.IoUtil;
-import cn.hutool.core.lang.func.Filter;
 import cn.hutool.core.lang.mutable.Mutable;
 import cn.hutool.core.lang.mutable.MutableEntry;
-import cn.hutool.core.util.ArrayUtil;
-import cn.hutool.core.text.StrUtil;
 import cn.hutool.core.reflect.TypeUtil;
+import cn.hutool.core.text.StrUtil;
+import cn.hutool.core.util.ArrayUtil;
 import cn.hutool.json.serialize.GlobalSerializeMapping;
 import cn.hutool.json.serialize.JSONObjectSerializer;
 import cn.hutool.json.serialize.JSONSerializer;
@@ -21,6 +20,7 @@ import java.util.Enumeration;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.ResourceBundle;
+import java.util.function.Predicate;
 
 /**
  * 对象和JSON映射器，用于转换对象为JSON，支持：
@@ -65,10 +65,10 @@ public class ObjectMapper {
 	 * 将给定对象转换为{@link JSONObject}
 	 *
 	 * @param jsonObject 目标{@link JSONObject}
-	 * @param filter     键值对过滤编辑器，可以通过实现此接口，完成解析前对键值对的过滤和修改操作
+	 * @param predicate  键值对过滤编辑器，可以通过实现此接口，完成解析前对键值对的过滤和修改操作，{@link Predicate#test(Object)}为{@code true}保留
 	 */
 	@SuppressWarnings({"rawtypes", "unchecked"})
-	public void map(final JSONObject jsonObject, final Filter<MutableEntry<String, Object>> filter) {
+	public void map(final JSONObject jsonObject, final Predicate<MutableEntry<String, Object>> predicate) {
 		final Object source = this.source;
 		if (null == source) {
 			return;
@@ -89,29 +89,29 @@ public class ObjectMapper {
 		if (source instanceof Map) {
 			// Map
 			for (final Map.Entry<?, ?> e : ((Map<?, ?>) source).entrySet()) {
-				jsonObject.set(Convert.toStr(e.getKey()), e.getValue(), filter, false);
+				jsonObject.set(Convert.toStr(e.getKey()), e.getValue(), predicate, false);
 			}
 		} else if (source instanceof Map.Entry) {
 			final Map.Entry entry = (Map.Entry) source;
-			jsonObject.set(Convert.toStr(entry.getKey()), entry.getValue(), filter, false);
+			jsonObject.set(Convert.toStr(entry.getKey()), entry.getValue(), predicate, false);
 		} else if (source instanceof CharSequence) {
 			// 可能为JSON字符串
-			mapFromStr((CharSequence) source, jsonObject, filter);
+			mapFromStr((CharSequence) source, jsonObject, predicate);
 		} else if (source instanceof Reader) {
-			mapFromTokener(new JSONTokener((Reader) source, jsonObject.getConfig()), jsonObject, filter);
+			mapFromTokener(new JSONTokener((Reader) source, jsonObject.getConfig()), jsonObject, predicate);
 		} else if (source instanceof InputStream) {
-			mapFromTokener(new JSONTokener((InputStream) source, jsonObject.getConfig()), jsonObject, filter);
+			mapFromTokener(new JSONTokener((InputStream) source, jsonObject.getConfig()), jsonObject, predicate);
 		} else if (source instanceof byte[]) {
-			mapFromTokener(new JSONTokener(IoUtil.toStream((byte[]) source), jsonObject.getConfig()), jsonObject, filter);
+			mapFromTokener(new JSONTokener(IoUtil.toStream((byte[]) source), jsonObject.getConfig()), jsonObject, predicate);
 		} else if (source instanceof JSONTokener) {
 			// JSONTokener
-			mapFromTokener((JSONTokener) source, jsonObject, filter);
+			mapFromTokener((JSONTokener) source, jsonObject, predicate);
 		} else if (source instanceof ResourceBundle) {
 			// JSONTokener
-			mapFromResourceBundle((ResourceBundle) source, jsonObject, filter);
+			mapFromResourceBundle((ResourceBundle) source, jsonObject, predicate);
 		} else if (BeanUtil.isReadableBean(source.getClass())) {
 			// 普通Bean
-			mapFromBean(source, jsonObject, filter);
+			mapFromBean(source, jsonObject, predicate);
 		} else {
 			// 不支持对象类型转换为JSONObject
 			throw new JSONException("Unsupported type [{}] to JSONObject!", source.getClass());
@@ -122,11 +122,11 @@ public class ObjectMapper {
 	 * 将给定对象转换为{@link JSONArray}
 	 *
 	 * @param jsonArray 目标{@link JSONArray}
-	 * @param filter    键值对过滤编辑器，可以通过实现此接口，完成解析前对值的过滤和修改操作，{@code null}表示不过滤
+	 * @param predicate 键值对过滤编辑器，可以通过实现此接口，完成解析前对值的过滤和修改操作，{@code null}表示不过滤，{@link Predicate#test(Object)}为{@code true}保留
 	 * @throws JSONException 非数组或集合
 	 */
 	@SuppressWarnings({"rawtypes", "unchecked"})
-	public void map(final JSONArray jsonArray, final Filter<Mutable<Object>> filter) throws JSONException {
+	public void map(final JSONArray jsonArray, final Predicate<Mutable<Object>> predicate) throws JSONException {
 		final Object source = this.source;
 		if (null == source) {
 			return;
@@ -138,15 +138,15 @@ public class ObjectMapper {
 			serializer.serialize(jsonArray, source);
 		} else if (source instanceof CharSequence) {
 			// JSON字符串
-			mapFromStr((CharSequence) source, jsonArray, filter);
+			mapFromStr((CharSequence) source, jsonArray, predicate);
 		} else if (source instanceof Reader) {
-			mapFromTokener(new JSONTokener((Reader) source, jsonArray.getConfig()), jsonArray, filter);
+			mapFromTokener(new JSONTokener((Reader) source, jsonArray.getConfig()), jsonArray, predicate);
 		} else if (source instanceof InputStream) {
-			mapFromTokener(new JSONTokener((InputStream) source, jsonArray.getConfig()), jsonArray, filter);
+			mapFromTokener(new JSONTokener((InputStream) source, jsonArray.getConfig()), jsonArray, predicate);
 		} else if (source instanceof byte[]) {
 			final byte[] bytesSource = (byte[]) source;
 			if ('[' == bytesSource[0] && ']' == bytesSource[bytesSource.length - 1]) {
-				mapFromTokener(new JSONTokener(IoUtil.toStream(bytesSource), jsonArray.getConfig()), jsonArray, filter);
+				mapFromTokener(new JSONTokener(IoUtil.toStream(bytesSource), jsonArray.getConfig()), jsonArray, predicate);
 			} else {
 				// https://github.com/dromara/hutool/issues/2369
 				// 非标准的二进制流，则按照普通数组对待
@@ -155,7 +155,7 @@ public class ObjectMapper {
 				}
 			}
 		} else if (source instanceof JSONTokener) {
-			mapFromTokener((JSONTokener) source, jsonArray, filter);
+			mapFromTokener((JSONTokener) source, jsonArray, predicate);
 		} else {
 			final Iterator<?> iter;
 			if (ArrayUtil.isArray(source)) {// 数组
@@ -174,7 +174,7 @@ public class ObjectMapper {
 				next = iter.next();
 				// 检查循环引用
 				if (next != source) {
-					jsonArray.addRaw(JSONUtil.wrap(next, config), filter);
+					jsonArray.addRaw(JSONUtil.wrap(next, config), predicate);
 				}
 			}
 		}
@@ -185,15 +185,15 @@ public class ObjectMapper {
 	 *
 	 * @param bundle     ResourceBundle
 	 * @param jsonObject {@link JSONObject}
-	 * @param filter     键值对过滤编辑器，可以通过实现此接口，完成解析前对键值对的过滤和修改操作，{@code null}表示不过滤
+	 * @param predicate  键值对过滤编辑器，可以通过实现此接口，完成解析前对键值对的过滤和修改操作，{@code null}表示不过滤，{@link Predicate#test(Object)}为{@code true}保留
 	 * @since 5.3.1
 	 */
-	private static void mapFromResourceBundle(final ResourceBundle bundle, final JSONObject jsonObject, final Filter<MutableEntry<String, Object>> filter) {
+	private static void mapFromResourceBundle(final ResourceBundle bundle, final JSONObject jsonObject, final Predicate<MutableEntry<String, Object>> predicate) {
 		final Enumeration<String> keys = bundle.getKeys();
 		while (keys.hasMoreElements()) {
 			final String key = keys.nextElement();
 			if (key != null) {
-				InternalJSONUtil.propertyPut(jsonObject, key, bundle.getString(key), filter);
+				InternalJSONUtil.propertyPut(jsonObject, key, bundle.getString(key), predicate);
 			}
 		}
 	}
@@ -203,16 +203,16 @@ public class ObjectMapper {
 	 *
 	 * @param source     JSON字符串
 	 * @param jsonObject {@link JSONObject}
-	 * @param filter     键值对过滤编辑器，可以通过实现此接口，完成解析前对键值对的过滤和修改操作，{@code null}表示不过滤
+	 * @param predicate  键值对过滤编辑器，可以通过实现此接口，完成解析前对键值对的过滤和修改操作，{@code null}表示不过滤，{@link Predicate#test(Object)}为{@code true}保留
 	 */
-	private static void mapFromStr(final CharSequence source, final JSONObject jsonObject, final Filter<MutableEntry<String, Object>> filter) {
+	private static void mapFromStr(final CharSequence source, final JSONObject jsonObject, final Predicate<MutableEntry<String, Object>> predicate) {
 		final String jsonStr = StrUtil.trim(source);
 		if (StrUtil.startWith(jsonStr, '<')) {
 			// 可能为XML
 			XML.toJSONObject(jsonObject, jsonStr, false);
 			return;
 		}
-		mapFromTokener(new JSONTokener(StrUtil.trim(source), jsonObject.getConfig()), jsonObject, filter);
+		mapFromTokener(new JSONTokener(StrUtil.trim(source), jsonObject.getConfig()), jsonObject, predicate);
 	}
 
 	/**
@@ -220,11 +220,11 @@ public class ObjectMapper {
 	 *
 	 * @param source    JSON字符串
 	 * @param jsonArray {@link JSONArray}
-	 * @param filter    值过滤编辑器，可以通过实现此接口，完成解析前对值的过滤和修改操作，{@code null}表示不过滤
+	 * @param predicate    值过滤编辑器，可以通过实现此接口，完成解析前对值的过滤和修改操作，{@code null}表示不过滤，，{@link Predicate#test(Object)}为{@code true}保留
 	 */
-	private void mapFromStr(final CharSequence source, final JSONArray jsonArray, final Filter<Mutable<Object>> filter) {
+	private void mapFromStr(final CharSequence source, final JSONArray jsonArray, final Predicate<Mutable<Object>> predicate) {
 		if (null != source) {
-			mapFromTokener(new JSONTokener(StrUtil.trim(source), jsonArray.getConfig()), jsonArray, filter);
+			mapFromTokener(new JSONTokener(StrUtil.trim(source), jsonArray.getConfig()), jsonArray, predicate);
 		}
 	}
 
@@ -233,10 +233,10 @@ public class ObjectMapper {
 	 *
 	 * @param x          JSONTokener
 	 * @param jsonObject {@link JSONObject}
-	 * @param filter     键值对过滤编辑器，可以通过实现此接口，完成解析前对键值对的过滤和修改操作
+	 * @param predicate  键值对过滤编辑器，可以通过实现此接口，完成解析前对键值对的过滤和修改操作，{@link Predicate#test(Object)}为{@code true}保留
 	 */
-	private static void mapFromTokener(final JSONTokener x, final JSONObject jsonObject, final Filter<MutableEntry<String, Object>> filter) {
-		JSONParser.of(x).parseTo(jsonObject, filter);
+	private static void mapFromTokener(final JSONTokener x, final JSONObject jsonObject, final Predicate<MutableEntry<String, Object>> predicate) {
+		JSONParser.of(x).parseTo(jsonObject, predicate);
 	}
 
 	/**
@@ -244,22 +244,23 @@ public class ObjectMapper {
 	 *
 	 * @param x         {@link JSONTokener}
 	 * @param jsonArray {@link JSONArray}
-	 * @param filter    值过滤编辑器，可以通过实现此接口，完成解析前对值的过滤和修改操作，{@code null}表示不过滤
+	 * @param predicate 值过滤编辑器，可以通过实现此接口，完成解析前对值的过滤和修改操作，{@code null}表示不过滤，{@link Predicate#test(Object)}为{@code true}保留
 	 */
-	private static void mapFromTokener(final JSONTokener x, final JSONArray jsonArray, final Filter<Mutable<Object>> filter) {
-		JSONParser.of(x).parseTo(jsonArray, filter);
+	private static void mapFromTokener(final JSONTokener x, final JSONArray jsonArray, final Predicate<Mutable<Object>> predicate) {
+		JSONParser.of(x).parseTo(jsonArray, predicate);
 	}
 
 	/**
 	 * 从Bean转换
 	 *
 	 * @param bean       Bean对象
+	 * @param predicate  过滤器，，{@link Predicate#test(Object)}为{@code true}保留，null表示保留。
 	 * @param jsonObject {@link JSONObject}
 	 */
-	private static void mapFromBean(final Object bean, final JSONObject jsonObject, final Filter<MutableEntry<String, Object>> filter) {
+	private static void mapFromBean(final Object bean, final JSONObject jsonObject, final Predicate<MutableEntry<String, Object>> predicate) {
 		final CopyOptions copyOptions = InternalJSONUtil.toCopyOptions(jsonObject.getConfig());
-		if (null != filter) {
-			copyOptions.setFieldEditor((entry -> filter.accept(entry) ? entry : null));
+		if (null != predicate) {
+			copyOptions.setFieldEditor((entry -> predicate.test(entry) ? entry : null));
 		}
 		BeanUtil.beanToMap(bean, jsonObject, copyOptions);
 	}
diff --git a/hutool-poi/src/main/java/cn/hutool/poi/excel/sax/handler/AbstractRowHandler.java b/hutool-poi/src/main/java/cn/hutool/poi/excel/sax/handler/AbstractRowHandler.java
index a37d34d5f..dff6614c8 100644
--- a/hutool-poi/src/main/java/cn/hutool/poi/excel/sax/handler/AbstractRowHandler.java
+++ b/hutool-poi/src/main/java/cn/hutool/poi/excel/sax/handler/AbstractRowHandler.java
@@ -1,9 +1,9 @@
 package cn.hutool.poi.excel.sax.handler;
 
 import cn.hutool.core.lang.Assert;
-import cn.hutool.core.lang.func.Func1;
 
 import java.util.List;
+import java.util.function.Function;
 
 /**
  * 抽象行数据处理器，通过实现{@link #handle(int, long, List)} 处理原始数据<br>
@@ -26,7 +26,7 @@ public abstract class AbstractRowHandler<T> implements RowHandler {
 	/**
 	 * 行数据转换函数
 	 */
-	protected Func1<List<Object>, T> convertFunc;
+	protected Function<List<Object>, T> convertFunc;
 
 	/**
 	 * 构造
@@ -45,7 +45,7 @@ public abstract class AbstractRowHandler<T> implements RowHandler {
 		if (rowIndex < this.startRowIndex || rowIndex > this.endRowIndex) {
 			return;
 		}
-		handleData(sheetIndex, rowIndex, convertFunc.callWithRuntimeException(rowCells));
+		handleData(sheetIndex, rowIndex, convertFunc.apply(rowCells));
 	}
 
 	/**