From a745f1be8086e5f45b3e3e7da94c422f2677640a Mon Sep 17 00:00:00 2001 From: Looly Date: Sun, 26 Mar 2023 17:15:17 +0800 Subject: [PATCH] fix code --- .../cn/hutool/core/bean/BeanInfoCache.java | 3 + .../java/cn/hutool/core/bean/BeanPath.java | 9 +- .../main/java/cn/hutool/core/codec/Morse.java | 3 +- .../java/cn/hutool/core/codec/PunyCode.java | 8 +- .../cn/hutool/core/collection/CollUtil.java | 36 +- .../core/comparator/VersionComparator.java | 8 +- .../core/convert/impl/ArrayConverter.java | 4 +- .../java/cn/hutool/core/date/DateUtil.java | 11 +- .../cn/hutool/core/io/file/FileNameUtil.java | 3 +- .../java/cn/hutool/core/io/file/FileUtil.java | 5 +- .../java/cn/hutool/core/net/Ipv4Pool.java | 4 +- .../java/cn/hutool/core/net/Ipv4Util.java | 5 +- .../main/java/cn/hutool/core/net/NetUtil.java | 6 +- .../java/cn/hutool/core/net/url/UrlPath.java | 3 +- .../cn/hutool/core/reflect/ClassUtil.java | 3 +- .../cn/hutool/core/text/AntPathMatcher.java | 3 +- .../cn/hutool/core/text/CharSequenceUtil.java | 350 +------------- .../java/cn/hutool/core/text/StrEditor.java | 5 - .../java/cn/hutool/core/text/StrRepeater.java | 164 +++++++ .../hutool/core/text/dfa/SensitiveUtil.java | 13 +- .../cn/hutool/core/text/split/SplitUtil.java | 435 ++++++------------ .../hutool/core/codec/hash/SimhashTest.java | 5 +- .../cn/hutool/core/text/SplitUtilTest.java | 50 ++ .../cn/hutool/core/text/StrRepeaterTest.java | 21 + .../java/cn/hutool/core/text/StrUtilTest.java | 55 +-- .../core/text/split/StrSplitterTest.java | 24 +- .../cron/pattern/parser/PartParser.java | 14 +- .../cron/pattern/parser/PatternParser.java | 4 +- .../main/java/cn/hutool/db/sql/Condition.java | 17 +- .../java/cn/hutool/db/sql/QuoteWrapper.java | 8 +- .../java/cn/hutool/db/meta/MetaUtilTest.java | 3 +- .../java/cn/hutool/extra/mail/MailUtil.java | 5 +- .../extra/management/JavaRuntimeInfo.java | 26 +- .../cn/hutool/extra/pinyin/PinyinEngine.java | 3 +- .../cn/hutool/http/webservice/SoapClient.java | 3 +- .../java/cn/hutool/json/InternalJSONUtil.java | 3 +- .../src/main/java/cn/hutool/json/jwt/JWT.java | 4 +- .../java/cn/hutool/setting/AbsSetting.java | 3 +- .../java/cn/hutool/setting/SettingLoader.java | 8 +- .../cn/hutool/swing/img/color/ColorUtil.java | 25 +- 40 files changed, 550 insertions(+), 812 deletions(-) delete mode 100644 hutool-core/src/main/java/cn/hutool/core/text/StrEditor.java create mode 100644 hutool-core/src/main/java/cn/hutool/core/text/StrRepeater.java create mode 100644 hutool-core/src/test/java/cn/hutool/core/text/StrRepeaterTest.java diff --git a/hutool-core/src/main/java/cn/hutool/core/bean/BeanInfoCache.java b/hutool-core/src/main/java/cn/hutool/core/bean/BeanInfoCache.java index 23864073f..c9f484070 100755 --- a/hutool-core/src/main/java/cn/hutool/core/bean/BeanInfoCache.java +++ b/hutool-core/src/main/java/cn/hutool/core/bean/BeanInfoCache.java @@ -14,6 +14,9 @@ import java.util.Map; * @author Looly */ public enum BeanInfoCache { + /** + * 单例 + */ INSTANCE; private final WeakConcurrentMap, Map> pdCache = new WeakConcurrentMap<>(); diff --git a/hutool-core/src/main/java/cn/hutool/core/bean/BeanPath.java b/hutool-core/src/main/java/cn/hutool/core/bean/BeanPath.java index ce8e3e58c..ed6f718b2 100644 --- a/hutool-core/src/main/java/cn/hutool/core/bean/BeanPath.java +++ b/hutool-core/src/main/java/cn/hutool/core/bean/BeanPath.java @@ -6,6 +6,7 @@ import cn.hutool.core.convert.Convert; import cn.hutool.core.map.MapUtil; import cn.hutool.core.math.NumberUtil; import cn.hutool.core.text.StrUtil; +import cn.hutool.core.text.split.SplitUtil; import cn.hutool.core.util.ArrayUtil; import cn.hutool.core.util.CharUtil; @@ -190,9 +191,9 @@ public class BeanPath implements Serializable { return null; } - if (StrUtil.contains(expression, ':')) { + if (StrUtil.contains(expression, CharUtil.COLON)) { // [start:end:step] 模式 - final List parts = StrUtil.splitTrim(expression, ':'); + final List parts = SplitUtil.splitTrim(expression, StrUtil.COLON); final int start = Integer.parseInt(parts.get(0)); final int end = Integer.parseInt(parts.get(1)); int step = 1; @@ -206,7 +207,7 @@ public class BeanPath implements Serializable { } } else if (StrUtil.contains(expression, ',')) { // [num0,num1,num2...]模式或者['key0','key1']模式 - final List keys = StrUtil.splitTrim(expression, ','); + final List keys = SplitUtil.splitTrim(expression, StrUtil.COMMA); if (bean instanceof Collection) { return CollUtil.getAny((Collection) bean, Convert.convert(int[].class, keys)); } else if (ArrayUtil.isArray(bean)) { @@ -214,7 +215,7 @@ public class BeanPath implements Serializable { } else { final String[] unWrappedKeys = new String[keys.size()]; for (int i = 0; i < unWrappedKeys.length; i++) { - unWrappedKeys[i] = StrUtil.unWrap(keys.get(i), '\''); + unWrappedKeys[i] = StrUtil.unWrap(keys.get(i), CharUtil.SINGLE_QUOTE); } if (bean instanceof Map) { // 只支持String为key的Map diff --git a/hutool-core/src/main/java/cn/hutool/core/codec/Morse.java b/hutool-core/src/main/java/cn/hutool/core/codec/Morse.java index 1e50431bd..b869c19b0 100644 --- a/hutool-core/src/main/java/cn/hutool/core/codec/Morse.java +++ b/hutool-core/src/main/java/cn/hutool/core/codec/Morse.java @@ -2,6 +2,7 @@ package cn.hutool.core.codec; import cn.hutool.core.lang.Assert; import cn.hutool.core.text.StrUtil; +import cn.hutool.core.text.split.SplitUtil; import cn.hutool.core.util.CharUtil; import java.util.HashMap; @@ -153,7 +154,7 @@ public class Morse { if (false == StrUtil.containsOnly(morse, dit, dah, split)) { throw new IllegalArgumentException("Incorrect morse."); } - final List words = StrUtil.split(morse, split); + final List words = SplitUtil.split(morse, String.valueOf(split)); final StringBuilder textBuilder = new StringBuilder(); Integer codePoint; for (String word : words) { diff --git a/hutool-core/src/main/java/cn/hutool/core/codec/PunyCode.java b/hutool-core/src/main/java/cn/hutool/core/codec/PunyCode.java index ddc441b50..13f50c110 100644 --- a/hutool-core/src/main/java/cn/hutool/core/codec/PunyCode.java +++ b/hutool-core/src/main/java/cn/hutool/core/codec/PunyCode.java @@ -3,6 +3,7 @@ package cn.hutool.core.codec; import cn.hutool.core.exceptions.UtilException; import cn.hutool.core.lang.Assert; import cn.hutool.core.text.StrUtil; +import cn.hutool.core.text.split.SplitUtil; import cn.hutool.core.util.CharUtil; import java.util.List; @@ -24,8 +25,7 @@ public class PunyCode { private static final int DAMP = 700; private static final int SKEW = 38; private static final char DELIMITER = '-'; - - public static final String PUNY_CODE_PREFIX = "xn--"; + private static final String PUNY_CODE_PREFIX = "xn--"; /** * 将域名编码为PunyCode，会忽略"."的编码 @@ -36,7 +36,7 @@ public class PunyCode { */ public static String encodeDomain(final String domain) throws UtilException { Assert.notNull(domain, "domain must not be null!"); - final List split = StrUtil.split(domain, CharUtil.DOT); + final List split = SplitUtil.split(domain, StrUtil.DOT); final StringBuilder result = new StringBuilder(domain.length() * 4); for (final String str : split) { if (result.length() != 0) { @@ -156,7 +156,7 @@ public class PunyCode { */ public static String decodeDomain(final String domain) throws UtilException { Assert.notNull(domain, "domain must not be null!"); - final List split = StrUtil.split(domain, CharUtil.DOT); + final List split = SplitUtil.split(domain, StrUtil.DOT); final StringBuilder result = new StringBuilder(domain.length() / 4 + 1); for (final String str : split) { if (result.length() != 0) { diff --git a/hutool-core/src/main/java/cn/hutool/core/collection/CollUtil.java b/hutool-core/src/main/java/cn/hutool/core/collection/CollUtil.java index 531378f2a..b0eaeaa5e 100755 --- a/hutool-core/src/main/java/cn/hutool/core/collection/CollUtil.java +++ b/hutool-core/src/main/java/cn/hutool/core/collection/CollUtil.java @@ -19,43 +19,17 @@ import cn.hutool.core.reflect.FieldUtil; import cn.hutool.core.reflect.TypeUtil; import cn.hutool.core.stream.StreamUtil; import cn.hutool.core.text.StrUtil; +import cn.hutool.core.text.split.SplitUtil; import cn.hutool.core.util.ArrayUtil; -import cn.hutool.core.util.CharUtil; import cn.hutool.core.util.ObjUtil; import java.lang.reflect.Type; -import java.util.AbstractCollection; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.Comparator; -import java.util.Deque; -import java.util.EnumSet; -import java.util.Enumeration; -import java.util.HashSet; -import java.util.Iterator; -import java.util.LinkedHashMap; -import java.util.LinkedHashSet; -import java.util.LinkedList; -import java.util.List; -import java.util.Map; +import java.util.*; import java.util.Map.Entry; -import java.util.NavigableSet; -import java.util.Objects; -import java.util.Optional; -import java.util.Set; -import java.util.SortedSet; -import java.util.Stack; -import java.util.TreeMap; -import java.util.TreeSet; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingDeque; -import java.util.function.BiConsumer; -import java.util.function.Function; -import java.util.function.Predicate; -import java.util.function.Supplier; -import java.util.function.UnaryOperator; +import java.util.function.*; import java.util.stream.Collectors; /** @@ -1350,7 +1324,7 @@ public class CollUtil { * @since 3.0.4 */ public static Map zip(final String keys, final String values, final String delimiter, final boolean isOrder) { - return ArrayUtil.zip(StrUtil.splitToArray(keys, delimiter), StrUtil.splitToArray(values, delimiter), isOrder); + return ArrayUtil.zip(SplitUtil.splitToArray(keys, delimiter), SplitUtil.splitToArray(values, delimiter), isOrder); } /** @@ -1550,7 +1524,7 @@ public class CollUtil { if (value instanceof CharSequence) { // String按照逗号分隔的列表对待 final String arrayStr = StrUtil.unWrap((CharSequence) value, '[', ']'); - iter = StrUtil.splitTrim(arrayStr, CharUtil.COMMA).iterator(); + iter = SplitUtil.splitTrim(arrayStr, StrUtil.COMMA).iterator(); } else { iter = IterUtil.getIter(value); } diff --git a/hutool-core/src/main/java/cn/hutool/core/comparator/VersionComparator.java b/hutool-core/src/main/java/cn/hutool/core/comparator/VersionComparator.java index 4ea067fb1..3586acbe5 100644 --- a/hutool-core/src/main/java/cn/hutool/core/comparator/VersionComparator.java +++ b/hutool-core/src/main/java/cn/hutool/core/comparator/VersionComparator.java @@ -1,8 +1,8 @@ package cn.hutool.core.comparator; -import cn.hutool.core.util.CharUtil; -import cn.hutool.core.util.ObjUtil; import cn.hutool.core.text.StrUtil; +import cn.hutool.core.text.split.SplitUtil; +import cn.hutool.core.util.ObjUtil; import java.io.Serializable; import java.util.Comparator; @@ -61,8 +61,8 @@ public class VersionComparator implements Comparator, Serializable { return 1; } - final List v1s = StrUtil.split(version1, CharUtil.DOT); - final List v2s = StrUtil.split(version2, CharUtil.DOT); + final List v1s = SplitUtil.splitTrim(version1, StrUtil.DOT); + final List v2s = SplitUtil.splitTrim(version2, StrUtil.DOT); int diff = 0; final int minLength = Math.min(v1s.size(), v2s.size());// 取最小长度值 diff --git a/hutool-core/src/main/java/cn/hutool/core/convert/impl/ArrayConverter.java b/hutool-core/src/main/java/cn/hutool/core/convert/impl/ArrayConverter.java index 0239f3543..0d4ee925e 100644 --- a/hutool-core/src/main/java/cn/hutool/core/convert/impl/ArrayConverter.java +++ b/hutool-core/src/main/java/cn/hutool/core/convert/impl/ArrayConverter.java @@ -6,9 +6,9 @@ import cn.hutool.core.convert.AbstractConverter; import cn.hutool.core.convert.Convert; import cn.hutool.core.io.SerializeUtil; import cn.hutool.core.text.StrUtil; +import cn.hutool.core.text.split.SplitUtil; import cn.hutool.core.util.ArrayUtil; import cn.hutool.core.util.ByteUtil; -import cn.hutool.core.util.CharUtil; import java.io.Serializable; import java.lang.reflect.Array; @@ -122,7 +122,7 @@ public class ArrayConverter extends AbstractConverter { } // 单纯字符串情况下按照逗号分隔后劈开 - final String[] strings = StrUtil.splitToArray(value.toString(), CharUtil.COMMA); + final String[] strings = SplitUtil.splitToArray(value.toString(), StrUtil.COMMA); return convertArrayToArray(targetComponentType, strings); } diff --git a/hutool-core/src/main/java/cn/hutool/core/date/DateUtil.java b/hutool-core/src/main/java/cn/hutool/core/date/DateUtil.java index a20c27a93..b501521b1 100755 --- a/hutool-core/src/main/java/cn/hutool/core/date/DateUtil.java +++ b/hutool-core/src/main/java/cn/hutool/core/date/DateUtil.java @@ -11,7 +11,7 @@ import cn.hutool.core.math.NumberUtil; import cn.hutool.core.regex.PatternPool; import cn.hutool.core.regex.ReUtil; import cn.hutool.core.text.StrUtil; -import cn.hutool.core.util.CharUtil; +import cn.hutool.core.text.split.SplitUtil; import javax.xml.datatype.XMLGregorianCalendar; import java.text.DateFormat; @@ -502,6 +502,7 @@ public class DateUtil extends CalendarUtil { } // region ----- format + /** * 格式化日期时间
* 格式 yyyy-MM-dd HH:mm:ss @@ -673,6 +674,7 @@ public class DateUtil extends CalendarUtil { // endregion // region ----- parse + /** * 构建DateTime对象 * @@ -829,6 +831,7 @@ public class DateUtil extends CalendarUtil { // endregion // region ----- offset + /** * 修改日期为某个时间字段起始时间 * @@ -1217,6 +1220,7 @@ public class DateUtil extends CalendarUtil { // endregion // region ----- between + /** * 判断两个日期相差的时长，只保留绝对值 * @@ -1325,6 +1329,7 @@ public class DateUtil extends CalendarUtil { // endregion // region ----- formatBetween + /** * 格式化日期间隔输出 * @@ -1626,7 +1631,7 @@ public class DateUtil extends CalendarUtil { return 0; } - final List hms = StrUtil.splitTrim(timeStr, CharUtil.COLON, 3); + final List hms = SplitUtil.split(timeStr, StrUtil.COLON, 3, true, true); final int lastIndex = hms.size() - 1; int result = 0; @@ -2071,7 +2076,7 @@ public class DateUtil extends CalendarUtil { } // 日期时间分开处理 - final List dateAndTime = StrUtil.splitTrim(dateStr, ' '); + final List dateAndTime = SplitUtil.splitTrim(dateStr, StrUtil.SPACE); final int size = dateAndTime.size(); if (size < 1 || size > 2) { // 非可被标准处理的格式 diff --git a/hutool-core/src/main/java/cn/hutool/core/io/file/FileNameUtil.java b/hutool-core/src/main/java/cn/hutool/core/io/file/FileNameUtil.java index 4ed0f07d8..f12dac33a 100755 --- a/hutool-core/src/main/java/cn/hutool/core/io/file/FileNameUtil.java +++ b/hutool-core/src/main/java/cn/hutool/core/io/file/FileNameUtil.java @@ -4,6 +4,7 @@ import cn.hutool.core.collection.CollUtil; import cn.hutool.core.net.url.URLUtil; import cn.hutool.core.regex.ReUtil; import cn.hutool.core.text.StrUtil; +import cn.hutool.core.text.split.SplitUtil; import cn.hutool.core.util.CharUtil; import cn.hutool.core.util.SystemUtil; @@ -387,7 +388,7 @@ public class FileNameUtil { pathToUse = pathToUse.substring(1); } - final List pathList = StrUtil.split(pathToUse, CharUtil.SLASH); + final List pathList = SplitUtil.split(pathToUse, StrUtil.SLASH); final List pathElements = new LinkedList<>(); int tops = 0; diff --git a/hutool-core/src/main/java/cn/hutool/core/io/file/FileUtil.java b/hutool-core/src/main/java/cn/hutool/core/io/file/FileUtil.java index 1536d6870..bb48e3fbf 100644 --- a/hutool-core/src/main/java/cn/hutool/core/io/file/FileUtil.java +++ b/hutool-core/src/main/java/cn/hutool/core/io/file/FileUtil.java @@ -14,6 +14,7 @@ import cn.hutool.core.net.url.URLUtil; import cn.hutool.core.reflect.ClassUtil; import cn.hutool.core.regex.ReUtil; import cn.hutool.core.text.StrUtil; +import cn.hutool.core.text.split.SplitUtil; import cn.hutool.core.thread.ThreadUtil; import cn.hutool.core.util.*; @@ -2973,13 +2974,13 @@ public class FileUtil extends PathUtil { */ private static File buildFile(File outFile, String fileName) { // 替换Windows路径分隔符为Linux路径分隔符，便于统一处理 - fileName = fileName.replace('\\', '/'); + fileName = fileName.replace(CharUtil.BACKSLASH, CharUtil.SLASH); if (false == isWindows() // 检查文件名中是否包含"/"，不考虑以"/"结尾的情况 && fileName.lastIndexOf(CharUtil.SLASH, fileName.length() - 2) > 0) { // 在Linux下多层目录创建存在问题，/会被当成文件名的一部分，此处做处理 // 使用/拆分路径（zip中无\），级联创建父目录 - final List pathParts = StrUtil.split(fileName, '/', false, true); + final List pathParts = SplitUtil.split(fileName, StrUtil.SLASH, false, true); final int lastPartIndex = pathParts.size() - 1;//目录个数 for (int i = 0; i < lastPartIndex; i++) { //由于路径拆分，slip不检查，在最后一步检查 diff --git a/hutool-core/src/main/java/cn/hutool/core/net/Ipv4Pool.java b/hutool-core/src/main/java/cn/hutool/core/net/Ipv4Pool.java index 172dcd22f..ac191185b 100644 --- a/hutool-core/src/main/java/cn/hutool/core/net/Ipv4Pool.java +++ b/hutool-core/src/main/java/cn/hutool/core/net/Ipv4Pool.java @@ -1,5 +1,7 @@ package cn.hutool.core.net; +import cn.hutool.core.text.StrUtil; + /** * Ip相关常量 * 
@@ -23,7 +25,7 @@ public interface Ipv4Pool {
     /**
      * IP与掩码的分割符
      */
-    String IP_MASK_SPLIT_MARK = "/";
+    String IP_MASK_SPLIT_MARK = StrUtil.SLASH;
 
     /**
      * localhost默认解析的ip地址
diff --git a/hutool-core/src/main/java/cn/hutool/core/net/Ipv4Util.java b/hutool-core/src/main/java/cn/hutool/core/net/Ipv4Util.java
index b600a24ec..1855ebd76 100755
--- a/hutool-core/src/main/java/cn/hutool/core/net/Ipv4Util.java
+++ b/hutool-core/src/main/java/cn/hutool/core/net/Ipv4Util.java
@@ -4,6 +4,7 @@ import cn.hutool.core.collection.ListUtil;
 import cn.hutool.core.lang.Assert;
 import cn.hutool.core.regex.PatternPool;
 import cn.hutool.core.text.StrUtil;
+import cn.hutool.core.text.split.SplitUtil;
 import cn.hutool.core.util.CharUtil;
 
 import java.util.ArrayList;
@@ -54,11 +55,11 @@ public class Ipv4Util implements Ipv4Pool {
 	public static List list(final String ipRange, final boolean isAll) {
 		if (ipRange.contains(IP_SPLIT_MARK)) {
 			// X.X.X.X-X.X.X.X
-			final String[] range = StrUtil.splitToArray(ipRange, IP_SPLIT_MARK);
+			final String[] range = SplitUtil.splitToArray(ipRange, IP_SPLIT_MARK);
 			return list(range[0], range[1]);
 		} else if (ipRange.contains(IP_MASK_SPLIT_MARK)) {
 			// X.X.X.X/X
-			final String[] param = StrUtil.splitToArray(ipRange, IP_MASK_SPLIT_MARK);
+			final String[] param = SplitUtil.splitToArray(ipRange, IP_MASK_SPLIT_MARK);
 			return list(param[0], Integer.parseInt(param[1]), isAll);
 		} else {
 			return ListUtil.of(ipRange);
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 480bbc0c5..a22ab2998 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
@@ -6,6 +6,8 @@ import cn.hutool.core.exceptions.UtilException;
 import cn.hutool.core.io.IORuntimeException;
 import cn.hutool.core.io.IoUtil;
 import cn.hutool.core.text.StrUtil;
+import cn.hutool.core.text.split.SplitUtil;
+import cn.hutool.core.util.CharUtil;
 import cn.hutool.core.util.JNDIUtil;
 import cn.hutool.core.util.RandomUtil;
 
@@ -744,8 +746,8 @@ public class NetUtil {
 	 */
 	public static String getMultistageReverseProxyIp(String ip) {
 		// 多级反向代理检测
-		if (ip != null && StrUtil.indexOf(ip, ',') > 0) {
-			final List ips = StrUtil.splitTrim(ip, ',');
+		if (ip != null && StrUtil.indexOf(ip, CharUtil.COMMA) > 0) {
+			final List ips = SplitUtil.splitTrim(ip, StrUtil.COMMA);
 			for (final String subIp : ips) {
 				if (false == isUnknown(subIp)) {
 					ip = subIp;
diff --git a/hutool-core/src/main/java/cn/hutool/core/net/url/UrlPath.java b/hutool-core/src/main/java/cn/hutool/core/net/url/UrlPath.java
index 9684fc72b..71618fac6 100644
--- a/hutool-core/src/main/java/cn/hutool/core/net/url/UrlPath.java
+++ b/hutool-core/src/main/java/cn/hutool/core/net/url/UrlPath.java
@@ -3,6 +3,7 @@ package cn.hutool.core.net.url;
 import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.collection.ListUtil;
 import cn.hutool.core.lang.Assert;
+import cn.hutool.core.text.split.SplitUtil;
 import cn.hutool.core.util.CharUtil;
 import cn.hutool.core.text.StrUtil;
 import cn.hutool.core.util.ObjUtil;
@@ -114,7 +115,7 @@ public class UrlPath {
 
 			path = fixPath(path);
 			if (StrUtil.isNotEmpty(path)) {
-				final List split = StrUtil.split(path, '/');
+				final List split = SplitUtil.split(path, StrUtil.SLASH);
 				for (final String seg : split) {
 					addInternal(URLDecoder.decodeForPath(seg, charset), false);
 				}
diff --git a/hutool-core/src/main/java/cn/hutool/core/reflect/ClassUtil.java b/hutool-core/src/main/java/cn/hutool/core/reflect/ClassUtil.java
index e40212402..5f59d3eb1 100644
--- a/hutool-core/src/main/java/cn/hutool/core/reflect/ClassUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/reflect/ClassUtil.java
@@ -9,6 +9,7 @@ import cn.hutool.core.io.resource.ResourceUtil;
 import cn.hutool.core.net.url.URLDecoder;
 import cn.hutool.core.net.url.URLUtil;
 import cn.hutool.core.text.StrUtil;
+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;
@@ -121,7 +122,7 @@ public class ClassUtil {
 	 * @since 4.1.9
 	 */
 	public static String getShortClassName(final String className) {
-		final List packages = StrUtil.split(className, CharUtil.DOT);
+		final List packages = SplitUtil.split(className, StrUtil.DOT);
 		if (null == packages || packages.size() < 2) {
 			return className;
 		}
diff --git a/hutool-core/src/main/java/cn/hutool/core/text/AntPathMatcher.java b/hutool-core/src/main/java/cn/hutool/core/text/AntPathMatcher.java
index 412b94d84..c07e16846 100755
--- a/hutool-core/src/main/java/cn/hutool/core/text/AntPathMatcher.java
+++ b/hutool-core/src/main/java/cn/hutool/core/text/AntPathMatcher.java
@@ -424,7 +424,8 @@ public class AntPathMatcher {
 	 * @return the tokenized path parts
 	 */
 	protected String[] tokenizePath(final String path) {
-		return SplitUtil.splitToArray(path, this.pathSeparator, 0, this.trimTokens, true);
+		return SplitUtil.split(path, this.pathSeparator, this.trimTokens, true)
+				.toArray(new String[0]);
 	}
 
 	/**
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 f64d97d02..2e849b5e3 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
@@ -2,7 +2,6 @@ package cn.hutool.core.text;
 
 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.SerFunction;
 import cn.hutool.core.math.NumberUtil;
@@ -1012,19 +1011,7 @@ public class CharSequenceUtil extends StrChecker {
 		if (null == str || ArrayUtil.isEmpty(chars)) {
 			return str(str);
 		}
-		final int len = str.length();
-		if (0 == len) {
-			return str(str);
-		}
-		final StringBuilder builder = new StringBuilder(len);
-		char c;
-		for (int i = 0; i < len; i++) {
-			c = str.charAt(i);
-			if (false == ArrayUtil.contains(chars, c)) {
-				builder.append(c);
-			}
-		}
-		return builder.toString();
+		return filter(str, (c)-> false == ArrayUtil.contains(chars, c));
 	}
 
 	/**
@@ -1288,270 +1275,6 @@ public class CharSequenceUtil extends StrChecker {
 	}
 	// endregion
 
-	// region ----- split
-
-	/**
-	 * 切分字符串为long数组
-	 *
-	 * @param str       被切分的字符串
-	 * @param separator 分隔符
-	 * @return 切分后long数组
-	 * @since 4.0.6
-	 */
-	public static long[] splitToLong(final CharSequence str, final char separator) {
-		return Convert.convert(long[].class, splitTrim(str, separator));
-	}
-
-	/**
-	 * 切分字符串为long数组
-	 *
-	 * @param str       被切分的字符串
-	 * @param separator 分隔符字符串
-	 * @return 切分后long数组
-	 * @since 4.0.6
-	 */
-	public static long[] splitToLong(final CharSequence str, final CharSequence separator) {
-		return Convert.convert(long[].class, splitTrim(str, separator));
-	}
-
-	/**
-	 * 切分字符串为int数组
-	 *
-	 * @param str       被切分的字符串
-	 * @param separator 分隔符
-	 * @return 切分后long数组
-	 * @since 4.0.6
-	 */
-	public static int[] splitToInt(final CharSequence str, final char separator) {
-		return Convert.convert(int[].class, splitTrim(str, separator));
-	}
-
-	/**
-	 * 切分字符串为int数组
-	 *
-	 * @param str       被切分的字符串
-	 * @param separator 分隔符字符串
-	 * @return 切分后long数组
-	 * @since 4.0.6
-	 */
-	public static int[] splitToInt(final CharSequence str, final CharSequence separator) {
-		return Convert.convert(int[].class, splitTrim(str, separator));
-	}
-
-	/**
-	 * 切分字符串

-	 * a#b#c =》 [a,b,c] 

-	 * a##b#c =》 [a,"",b,c]
-	 *
-	 * @param str       被切分的字符串
-	 * @param separator 分隔符字符
-	 * @return 切分后的集合
-	 */
-	public static List split(final CharSequence str, final char separator) {
-		return split(str, separator, 0);
-	}
-
-	/**
-	 * 切分字符串，如果分隔符不存在则返回原字符串
-	 *
-	 * @param str       被切分的字符串
-	 * @param separator 分隔符
-	 * @return 字符串
-	 * @since 5.6.7
-	 */
-	public static String[] splitToArray(final CharSequence str, final CharSequence separator) {
-		if (str == null) {
-			return new String[]{};
-		}
-
-		return SplitUtil.splitToArray(str.toString(), str(separator), 0, false, false);
-	}
-
-	/**
-	 * 切分字符串
-	 *
-	 * @param str       被切分的字符串
-	 * @param separator 分隔符字符
-	 * @return 切分后的数组
-	 */
-	public static String[] splitToArray(final CharSequence str, final char separator) {
-		return splitToArray(str, separator, 0);
-	}
-
-	/**
-	 * 切分字符串
-	 *
-	 * @param text      被切分的字符串
-	 * @param separator 分隔符字符
-	 * @param limit     限制分片数
-	 * @return 切分后的数组
-	 */
-	public static String[] splitToArray(final CharSequence text, final char separator, final int limit) {
-		Assert.notNull(text, "Text must be not null!");
-		return SplitUtil.splitToArray(text.toString(), separator, limit, false, false);
-	}
-
-	/**
-	 * 切分字符串，不去除切分后每个元素两边的空白符，不去除空白项
-	 *
-	 * @param str       被切分的字符串
-	 * @param separator 分隔符字符
-	 * @param limit     限制分片数，-1不限制
-	 * @return 切分后的集合
-	 */
-	public static List split(final CharSequence str, final char separator, final int limit) {
-		return split(str, separator, limit, false, false);
-	}
-
-	/**
-	 * 切分字符串，去除切分后每个元素两边的空白符，去除空白项
-	 *
-	 * @param str       被切分的字符串
-	 * @param separator 分隔符字符
-	 * @return 切分后的集合
-	 * @since 3.1.2
-	 */
-	public static List splitTrim(final CharSequence str, final char separator) {
-		return splitTrim(str, separator, -1);
-	}
-
-	/**
-	 * 切分字符串，去除切分后每个元素两边的空白符，去除空白项
-	 *
-	 * @param str       被切分的字符串
-	 * @param separator 分隔符字符
-	 * @return 切分后的集合
-	 * @since 3.2.0
-	 */
-	public static List splitTrim(final CharSequence str, final CharSequence separator) {
-		return splitTrim(str, separator, -1);
-	}
-
-	/**
-	 * 切分字符串，去除切分后每个元素两边的空白符，去除空白项
-	 *
-	 * @param str       被切分的字符串
-	 * @param separator 分隔符字符
-	 * @param limit     限制分片数，-1不限制
-	 * @return 切分后的集合
-	 * @since 3.1.0
-	 */
-	public static List splitTrim(final CharSequence str, final char separator, final int limit) {
-		return split(str, separator, limit, true, true);
-	}
-
-	/**
-	 * 切分字符串，去除切分后每个元素两边的空白符，去除空白项
-	 *
-	 * @param str       被切分的字符串
-	 * @param separator 分隔符字符
-	 * @param limit     限制分片数，-1不限制
-	 * @return 切分后的集合
-	 * @since 3.2.0
-	 */
-	public static List splitTrim(final CharSequence str, final CharSequence separator, final int limit) {
-		return split(str, separator, limit, true, true);
-	}
-
-	/**
-	 * 切分字符串，不限制分片数量
-	 *
-	 * @param str         被切分的字符串
-	 * @param separator   分隔符字符
-	 * @param isTrim      是否去除切分字符串后每个元素两边的空格
-	 * @param ignoreEmpty 是否忽略空串
-	 * @return 切分后的集合
-	 * @since 3.0.8
-	 */
-	public static List split(final CharSequence str, final char separator, final boolean isTrim, final boolean ignoreEmpty) {
-		return split(str, separator, 0, isTrim, ignoreEmpty);
-	}
-
-	/**
-	 * 切分字符串
-	 *
-	 * @param str         被切分的字符串
-	 * @param separator   分隔符字符
-	 * @param limit       限制分片数，-1不限制
-	 * @param isTrim      是否去除切分字符串后每个元素两边的空格
-	 * @param ignoreEmpty 是否忽略空串
-	 * @return 切分后的集合
-	 * @since 3.0.8
-	 */
-	public static List split(final CharSequence str, final char separator, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
-		return SplitUtil.split(str, separator, limit, isTrim, ignoreEmpty);
-	}
-
-	/**
-	 * 切分字符串
-	 *
-	 * @param          切分后元素类型
-	 * @param str         被切分的字符串
-	 * @param separator   分隔符字符
-	 * @param limit       限制分片数，-1不限制
-	 * @param ignoreEmpty 是否忽略空串
-	 * @param mapping     切分后的字符串元素的转换方法
-	 * @return 切分后的集合，元素类型是经过 mapping 转换后的
-	 * @since 5.7.14
-	 */
-	public static  List split(final CharSequence str, final char separator, final int limit, final boolean ignoreEmpty, final Function mapping) {
-		return SplitUtil.split(str, separator, limit, ignoreEmpty, mapping);
-	}
-
-	/**
-	 * 切分字符串，如果分隔符不存在则返回原字符串
-	 *
-	 * @param str       被切分的字符串
-	 * @param separator 分隔符
-	 * @return 字符串
-	 * @since 5.7.1
-	 */
-	public static List split(final CharSequence str, final CharSequence separator) {
-		return split(str, separator, false, false);
-	}
-
-	/**
-	 * 切分字符串
-	 *
-	 * @param str         被切分的字符串
-	 * @param separator   分隔符字符
-	 * @param isTrim      是否去除切分字符串后每个元素两边的空格
-	 * @param ignoreEmpty 是否忽略空串
-	 * @return 切分后的集合
-	 * @since 5.6.7
-	 */
-	public static List split(final CharSequence str, final CharSequence separator, final boolean isTrim, final boolean ignoreEmpty) {
-		return split(str, separator, 0, isTrim, ignoreEmpty);
-	}
-
-	/**
-	 * 切分字符串
-	 *
-	 * @param str         被切分的字符串
-	 * @param separator   分隔符字符
-	 * @param limit       限制分片数，-1不限制
-	 * @param isTrim      是否去除切分字符串后每个元素两边的空格
-	 * @param ignoreEmpty 是否忽略空串
-	 * @return 切分后的集合
-	 * @since 3.2.0
-	 */
-	public static List split(final CharSequence str, final CharSequence separator, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
-		final String separatorStr = (null == separator) ? null : separator.toString();
-		return SplitUtil.split(str, separatorStr, limit, isTrim, ignoreEmpty);
-	}
-
-	/**
-	 * 根据给定长度，将给定字符串截取为多个部分
-	 *
-	 * @param str 字符串
-	 * @param len 每一个小节的长度
-	 * @return 截取后的字符串数组
-	 * @see SplitUtil#splitByLength(CharSequence, int)
-	 */
-	public static String[] splitToArray(final CharSequence str, final int len) {
-		return SplitUtil.splitByLength(str, len);
-	}
-
 	/**
 	 * 将字符串切分为N等份
 	 *
@@ -1577,7 +1300,6 @@ public class CharSequenceUtil extends StrChecker {
 		}
 		return array;
 	}
-	// endregion
 
 	// region ----- sub
 
@@ -2044,7 +1766,7 @@ public class CharSequenceUtil extends StrChecker {
 		}
 
 		final List result = new LinkedList<>();
-		final String[] split = splitToArray(str, prefix);
+		final String[] split = SplitUtil.splitToArray(str, prefix);
 		if (prefix.equals(suffix)) {
 			// 前后缀字符相同，单独处理
 			for (int i = 1, length = split.length - 1; i < length; i += 2) {
@@ -2112,12 +1834,7 @@ public class CharSequenceUtil extends StrChecker {
 		if (count <= 0) {
 			return EMPTY;
 		}
-
-		final char[] result = new char[count];
-		for (int i = 0; i < count; i++) {
-			result[i] = c;
-		}
-		return new String(result);
+		return StrRepeater.of(count).repeat(c);
 	}
 
 	/**
@@ -2131,33 +1848,15 @@ public class CharSequenceUtil extends StrChecker {
 		if (null == str) {
 			return null;
 		}
-		if (count <= 0 || str.length() == 0) {
-			return EMPTY;
-		}
-		if (count == 1) {
-			return str.toString();
-		}
-
-		// 检查
-		final int len = str.length();
-		final long longSize = (long) len * (long) count;
-		final int size = (int) longSize;
-		if (size != longSize) {
-			throw new ArrayIndexOutOfBoundsException("Required String length is too large: " + longSize);
-		}
-
-		final char[] array = new char[size];
-		str.toString().getChars(0, len, array, 0);
-		int n;
-		for (n = len; n < size - n; n <<= 1) {// n <<= 1相当于n *2
-			System.arraycopy(array, 0, array, n, n);
-		}
-		System.arraycopy(array, 0, array, n, size - n);
-		return new String(array);
+		return StrRepeater.of(count).repeat(str);
 	}
 
 	/**
 	 * 重复某个字符串到指定长度
+	 * 
    
+	 *     
  • 如果指定长度非指定字符串的整数倍，截断到固定长度
    • 
+	 *     
  • 如果指定长度小于字符串本身的长度，截断之
    • 
+	 * 

 	 *
 	 * @param str    被重复的字符
 	 * @param padLen 指定长度
@@ -2171,19 +1870,7 @@ public class CharSequenceUtil extends StrChecker {
 		if (padLen <= 0) {
 			return EMPTY;
 		}
-		final int strLen = str.length();
-		if (strLen == padLen) {
-			return str.toString();
-		} else if (strLen > padLen) {
-			return subPre(str, padLen);
-		}
-
-		// 重复，直到达到指定长度
-		final char[] padding = new char[padLen];
-		for (int i = 0; i < padLen; i++) {
-			padding[i] = str.charAt(i % strLen);
-		}
-		return new String(padding);
+		return StrRepeater.of(padLen).repeatByLength(str);
 	}
 
 	/**
@@ -2201,22 +1888,11 @@ public class CharSequenceUtil extends StrChecker {
 	 * @return 连接后的字符串
 	 * @since 4.0.1
 	 */
-	public static String repeatAndJoin(final CharSequence str, int count, final CharSequence delimiter) {
+	public static String repeatAndJoin(final CharSequence str, final int count, final CharSequence delimiter) {
 		if (count <= 0) {
 			return EMPTY;
 		}
-		final StringBuilder builder = new StringBuilder(str.length() * count);
-		builder.append(str);
-		count--;
-
-		final boolean isAppendDelimiter = isNotEmpty(delimiter);
-		while (count-- > 0) {
-			if (isAppendDelimiter) {
-				builder.append(delimiter);
-			}
-			builder.append(str);
-		}
-		return builder.toString();
+		return StrRepeater.of(count).repeatAndJoin(str, delimiter);
 	}
 	// endregion
 
@@ -2368,8 +2044,8 @@ public class CharSequenceUtil extends StrChecker {
 	 * @param str2       第二个字符串
 	 * @param ignoreCase 是否忽略大小写
 	 * @return 子串是否相同
-	 * @since 3.2.1
 	 * @see String#regionMatches(boolean, int, String, int, int)
+	 * @since 3.2.1
 	 */
 	public static boolean isSubEquals(final CharSequence str1, final int start1,
 									  final CharSequence str2, final boolean ignoreCase) {
@@ -2387,8 +2063,8 @@ public class CharSequenceUtil extends StrChecker {
 	 * @param length     截取长度
 	 * @param ignoreCase 是否忽略大小写
 	 * @return 子串是否相同
-	 * @since 3.2.1
 	 * @see String#regionMatches(boolean, int, String, int, int)
+	 * @since 3.2.1
 	 */
 	public static boolean isSubEquals(final CharSequence str1, final int start1,
 									  final CharSequence str2, final int start2, final int length,
diff --git a/hutool-core/src/main/java/cn/hutool/core/text/StrEditor.java b/hutool-core/src/main/java/cn/hutool/core/text/StrEditor.java
deleted file mode 100644
index d17f2e902..000000000
--- a/hutool-core/src/main/java/cn/hutool/core/text/StrEditor.java
+++ /dev/null
@@ -1,5 +0,0 @@
-package cn.hutool.core.text;
-
-public class StrEditor {
-	private
-}
diff --git a/hutool-core/src/main/java/cn/hutool/core/text/StrRepeater.java b/hutool-core/src/main/java/cn/hutool/core/text/StrRepeater.java
new file mode 100644
index 000000000..643381ec4
--- /dev/null
+++ b/hutool-core/src/main/java/cn/hutool/core/text/StrRepeater.java
@@ -0,0 +1,164 @@
+package cn.hutool.core.text;
+
+/**
+ * 字符串或字符重复器

+ * 用于将给定字符串或字符赋值count次，然后拼接
+ *
+ * @author looly
+ * @since 6.0.0
+ */
+public class StrRepeater {
+	private final int countOrLength;
+
+	/**
+	 * 创建StrRepeater
+	 *
+	 * @param countOrLength 重复次数或固定长度
+	 * @return StrRepeater
+	 */
+	public static StrRepeater of(final int countOrLength) {
+		return new StrRepeater(countOrLength);
+	}
+
+	/**
+	 * 构造
+	 *
+	 * @param countOrLength 重复次数或固定长度
+	 */
+	public StrRepeater(final int countOrLength) {
+		this.countOrLength = countOrLength;
+	}
+
+	/**
+	 * 重复某个字符
+	 *
+	 * 
+	 * repeat('e', 0)  = ""
+	 * repeat('e', 3)  = "eee"
+	 * repeat('e', -2) = ""
+	 * 

+	 *
+	 * @param c 被重复的字符
+	 * @return 重复字符字符串
+	 */
+	public String repeat(final char c) {
+		final int count = this.countOrLength;
+		if (count <= 0) {
+			return StrUtil.EMPTY;
+		}
+
+		final char[] result = new char[count];
+		for (int i = 0; i < count; i++) {
+			result[i] = c;
+		}
+		return new String(result);
+	}
+
+	/**
+	 * 重复某个字符串
+	 *
+	 * @param str 被重复的字符
+	 * @return 重复字符字符串
+	 */
+	public String repeat(final CharSequence str) {
+		if (null == str) {
+			return null;
+		}
+
+		final int count = this.countOrLength;
+		if (count <= 0 || str.length() == 0) {
+			return StrUtil.EMPTY;
+		}
+		if (count == 1) {
+			return str.toString();
+		}
+
+		// 检查
+		final int len = str.length();
+		final long longSize = (long) len * (long) count;
+		final int size = (int) longSize;
+		if (size != longSize) {
+			throw new ArrayIndexOutOfBoundsException("Required String length is too large: " + longSize);
+		}
+
+		// 相比使用StringBuilder更高效
+		final char[] array = new char[size];
+		str.toString().getChars(0, len, array, 0);
+		int n;
+		for (n = len; n < size - n; n <<= 1) {// n <<= 1相当于n *2
+			System.arraycopy(array, 0, array, n, n);
+		}
+		System.arraycopy(array, 0, array, n, size - n);
+		return new String(array);
+	}
+
+	/**
+	 * 重复某个字符串到指定长度
+	 * 
    
+	 *     
  • 如果指定长度非指定字符串的整数倍，截断到固定长度
    • 
+	 *     
  • 如果指定长度小于字符串本身的长度，截断之
    • 
+	 * 

+	 *
+	 * @param str 被重复的字符
+	 * @return 重复字符字符串
+	 * @since 4.3.2
+	 */
+	public String repeatByLength(final CharSequence str) {
+		if (null == str) {
+			return null;
+		}
+
+		final int padLen = this.countOrLength;
+		if (padLen <= 0) {
+			return StrUtil.EMPTY;
+		}
+		final int strLen = str.length();
+		if (strLen == padLen) {
+			return str.toString();
+		} else if (strLen > padLen) {
+			return StrUtil.subPre(str, padLen);
+		}
+
+		// 重复，直到达到指定长度
+		final char[] padding = new char[padLen];
+		for (int i = 0; i < padLen; i++) {
+			padding[i] = str.charAt(i % strLen);
+		}
+		return new String(padding);
+	}
+
+	/**
+	 * 重复某个字符串并通过分界符连接
+	 *
+	 * 
+	 * repeatAndJoin("?", 5, ",")   = "?,?,?,?,?"
+	 * repeatAndJoin("?", 0, ",")   = ""
+	 * repeatAndJoin("?", 5, null) = "?????"
+	 * 

+	 *
+	 * @param str       被重复的字符串
+	 * @param delimiter 分界符
+	 * @return 连接后的字符串
+	 * @since 4.0.1
+	 */
+	public String repeatAndJoin(final CharSequence str, final CharSequence delimiter) {
+		int count = this.countOrLength;
+		if (count <= 0) {
+			return StrUtil.EMPTY;
+		}
+		if(StrUtil.isEmpty(delimiter)){
+			return repeat(str);
+		}
+
+		// 初始大小 = 所有重复字符串长度 + 分界符总长度
+		final StringBuilder builder = new StringBuilder(
+				str.length() * count + delimiter.length() * (count - 1));
+		builder.append(str);
+		count--;
+
+		while (count-- > 0) {
+			builder.append(delimiter).append(str);
+		}
+		return builder.toString();
+	}
+}
diff --git a/hutool-core/src/main/java/cn/hutool/core/text/dfa/SensitiveUtil.java b/hutool-core/src/main/java/cn/hutool/core/text/dfa/SensitiveUtil.java
index ba03bb2a6..b002c8818 100755
--- a/hutool-core/src/main/java/cn/hutool/core/text/dfa/SensitiveUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/text/dfa/SensitiveUtil.java
@@ -1,9 +1,9 @@
 package cn.hutool.core.text.dfa;
 
 import cn.hutool.core.collection.CollUtil;
-import cn.hutool.core.thread.ThreadUtil;
 import cn.hutool.core.text.StrUtil;
-import cn.hutool.core.util.CharUtil;
+import cn.hutool.core.text.split.SplitUtil;
+import cn.hutool.core.thread.ThreadUtil;
 
 import java.util.Collection;
 import java.util.HashMap;
@@ -18,7 +18,10 @@ import java.util.function.Predicate;
  */
 public final class SensitiveUtil {
 
-	public static final char DEFAULT_SEPARATOR = CharUtil.COMMA;
+	/**
+	 * 默认关键词分隔符
+	 */
+	public static final String DEFAULT_SEPARATOR = StrUtil.COMMA;
 	private static final WordTree sensitiveTree = new WordTree();
 
 	/**
@@ -63,9 +66,9 @@ public final class SensitiveUtil {
 	 * @param isAsync        是否异步初始化
 	 * @param separator      分隔符
 	 */
-	public static void init(final String sensitiveWords, final char separator, final boolean isAsync) {
+	public static void init(final String sensitiveWords, final String separator, final boolean isAsync) {
 		if (StrUtil.isNotBlank(sensitiveWords)) {
-			init(StrUtil.split(sensitiveWords, separator), isAsync);
+			init(SplitUtil.split(sensitiveWords, separator), isAsync);
 		}
 	}
 
diff --git a/hutool-core/src/main/java/cn/hutool/core/text/split/SplitUtil.java b/hutool-core/src/main/java/cn/hutool/core/text/split/SplitUtil.java
index 7bc89cad4..b5e5780ff 100644
--- a/hutool-core/src/main/java/cn/hutool/core/text/split/SplitUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/text/split/SplitUtil.java
@@ -1,13 +1,11 @@
 package cn.hutool.core.text.split;
 
 import cn.hutool.core.collection.ListUtil;
+import cn.hutool.core.convert.Convert;
+import cn.hutool.core.lang.Assert;
 import cn.hutool.core.regex.PatternPool;
 import cn.hutool.core.text.StrUtil;
-import cn.hutool.core.text.finder.CharFinder;
-import cn.hutool.core.text.finder.CharMatcherFinder;
-import cn.hutool.core.text.finder.LengthFinder;
-import cn.hutool.core.text.finder.PatternFinder;
-import cn.hutool.core.text.finder.StrFinder;
+import cn.hutool.core.text.finder.*;
 import cn.hutool.core.util.CharUtil;
 
 import java.util.ArrayList;
@@ -17,205 +15,74 @@ import java.util.regex.Pattern;
 
 /**
  * 字符串切分器，封装统一的字符串分割静态方法
+ *
  * @author Looly
  * @since 5.7.0
  */
 public class SplitUtil {
 
-	//---------------------------------------------------------------------------------------------- Split by char
+	/**
+	 * 无限制切分个数
+	 */
+	public static int UNLIMITED = -1;
+
+	// region ----- split to
 
 	/**
-	 * 切分字符串路径，仅支持Unix分界符：/
-	 * 
去除每个元素两边空格，大小写敏感，忽略空串

+	 * 切分字符串，去除切分后每个元素两边的空白符，去除空白项，并转为结果类型
 	 *
-	 * @param str 被切分的字符串
+	 * @param         结果类型
+	 * @param str        被切分的字符串
+	 * @param separator  分隔符字符
+	 * @param resultType 结果类型的类，可以是数组或集合
+	 * @return long数组
+	 */
+	public static  T splitTo(final CharSequence str, final CharSequence separator, final Class resultType) {
+		return Convert.convert(resultType, splitTrim(str, separator));
+	}
+	// endregion
+
+	// region ----- Split by String or char
+
+	/**
+	 * 切分字符串，去除切分后每个元素两边的空白符，去除空白项
+	 *
+	 * @param str       被切分的字符串
+	 * @param separator 分隔符字符
 	 * @return 切分后的集合
-	 * @since 3.0.8
+	 * @since 3.2.0
 	 */
-	public static List splitPath(final CharSequence str) {
-		return splitPath(str, 0);
+	public static List splitTrim(final CharSequence str, final CharSequence separator) {
+		return split(str, separator, true, true);
 	}
 
 	/**
-	 * 切分字符串路径，仅支持Unix分界符：/
-	 * 
去除每个元素两边空格，大小写敏感，忽略空串

+	 * 切分字符串，如果分隔符不存在则返回原字符串

+	 * 此方法不会去除切分字符串后每个元素两边的空格，不忽略空串
 	 *
-	 * @param str 被切分的字符串
-	 * @return 切分后的集合
-	 * @since 3.0.8
+	 * @param str       被切分的字符串
+	 * @param separator 分隔符
+	 * @return 字符串
 	 */
-	public static String[] splitPathToArray(final CharSequence str) {
-		return toArray(splitPath(str));
-	}
-
-	/**
-	 * 切分字符串路径，仅支持Unix分界符：/
-	 * 
去除每个元素两边空格，大小写敏感，忽略空串

-	 *
-	 * @param str   被切分的字符串
-	 * @param limit 限制分片数，小于等于0表示无限制
-	 * @return 切分后的集合
-	 * @since 3.0.8
-	 */
-	public static List splitPath(final CharSequence str, final int limit) {
-		return split(str, CharUtil.SLASH, limit, true, true);
-	}
-
-	/**
-	 * 切分字符串路径，仅支持Unix分界符：/
-	 * 
去除每个元素两边空格，大小写敏感，忽略空串

-	 *
-	 * @param str   被切分的字符串
-	 * @param limit 限制分片数，小于等于0表示无限制
-	 * @return 切分后的集合
-	 * @since 3.0.8
-	 */
-	public static String[] splitPathToArray(final CharSequence str, final int limit) {
-		return toArray(splitPath(str, limit));
-	}
-
-	/**
-	 * 切分字符串，大小写敏感，去除每个元素两边空白符
-	 *
-	 * @param str         被切分的字符串
-	 * @param separator   分隔符字符
-	 * @param ignoreEmpty 是否忽略空串
-	 * @return 切分后的集合
-	 * @since 3.2.1
-	 */
-	public static List splitTrim(final CharSequence str, final char separator, final boolean ignoreEmpty) {
-		return split(str, separator, 0, true, ignoreEmpty);
-	}
-
-	/**
-	 * 切分字符串
-	 *
-	 * @param str         被切分的字符串
-	 * @param separator   分隔符字符
-	 * @param isTrim      是否去除切分字符串后每个元素两边的空格
-	 * @param ignoreEmpty 是否忽略空串
-	 * @return 切分后的集合
-	 * @since 3.0.8
-	 */
-	public static List split(final CharSequence str, final char separator, final boolean isTrim, final boolean ignoreEmpty) {
-		return split(str, separator, 0, isTrim, ignoreEmpty);
-	}
-
-	/**
-	 * 切分字符串，大小写敏感，去除每个元素两边空白符
-	 *
-	 * @param str         被切分的字符串
-	 * @param separator   分隔符字符
-	 * @param limit       限制分片数，小于等于0表示无限制
-	 * @param ignoreEmpty 是否忽略空串
-	 * @return 切分后的集合
-	 * @since 3.0.8
-	 */
-	public static List splitTrim(final CharSequence str, final char separator, final int limit, final boolean ignoreEmpty) {
-		return split(str, separator, limit, true, ignoreEmpty, false);
-	}
-
-	/**
-	 * 切分字符串，大小写敏感
-	 *
-	 * @param str         被切分的字符串
-	 * @param separator   分隔符字符
-	 * @param limit       限制分片数，小于等于0表示无限制
-	 * @param isTrim      是否去除切分字符串后每个元素两边的空格
-	 * @param ignoreEmpty 是否忽略空串
-	 * @return 切分后的集合
-	 * @since 3.0.8
-	 */
-	public static List split(final CharSequence str, final char separator, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
-		return split(str, separator, limit, isTrim, ignoreEmpty, false);
-	}
-
-	/**
-	 * 切分字符串，大小写敏感
-	 *
-	 * @param          切分后的元素类型
-	 * @param str         被切分的字符串
-	 * @param separator   分隔符字符
-	 * @param limit       限制分片数，小于等于0表示无限制
-	 * @param ignoreEmpty 是否忽略空串
-	 * @param mapping     切分后的字符串元素的转换方法
-	 * @return 切分后的集合，元素类型是经过 mapping 转换后的
-	 * @since 5.7.14
-	 */
-	public static  List split(final CharSequence str, final char separator, final int limit, final boolean ignoreEmpty, final Function mapping) {
-		return split(str, separator, limit, ignoreEmpty, false, mapping);
-	}
-
-	/**
-	 * 切分字符串，忽略大小写
-	 *
-	 * @param text        被切分的字符串
-	 * @param separator   分隔符字符
-	 * @param limit       限制分片数，小于等于0表示无限制
-	 * @param isTrim      是否去除切分字符串后每个元素两边的空格
-	 * @param ignoreEmpty 是否忽略空串
-	 * @return 切分后的集合
-	 * @since 3.2.1
-	 */
-	public static List splitIgnoreCase(final CharSequence text, final char separator, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
-		return split(text, separator, limit, isTrim, ignoreEmpty, true);
-	}
-
-	/**
-	 * 切分字符串
-	 *
-	 * @param text        被切分的字符串
-	 * @param separator   分隔符字符
-	 * @param limit       限制分片数，小于等于0表示无限制
-	 * @param isTrim      是否去除切分字符串后每个元素两边的空格
-	 * @param ignoreEmpty 是否忽略空串
-	 * @param ignoreCase  是否忽略大小写
-	 * @return 切分后的集合
-	 */
-	public static List split(final CharSequence text, final char separator, final int limit, final boolean isTrim, final boolean ignoreEmpty, final boolean ignoreCase) {
-		return split(text, separator, limit, ignoreEmpty, ignoreCase, trimFunc(isTrim));
-	}
-
-	/**
-	 * 切分字符串

-	 * 如果为空字符串或者null 则返回空集合
-	 *
-	 * @param          切分后的元素类型
-	 * @param text        被切分的字符串
-	 * @param separator   分隔符字符
-	 * @param limit       限制分片数，小于等于0表示无限制
-	 * @param ignoreEmpty 是否忽略空串
-	 * @param ignoreCase  是否忽略大小写
-	 * @param mapping     切分后的字符串元素的转换方法
-	 * @return 切分后的集合，元素类型是经过 mapping 转换后的
-	 * @since 5.7.14
-	 */
-	public static  List split(final CharSequence text, final char separator, final int limit, final boolean ignoreEmpty,
-									final boolean ignoreCase, final Function mapping) {
-		if (StrUtil.isEmpty(text)) {
-			return new ArrayList<>(0);
+	public static String[] splitToArray(final CharSequence str, final CharSequence separator) {
+		if (str == null) {
+			return new String[]{};
 		}
-		final SplitIter splitIter = new SplitIter(text, new CharFinder(separator, ignoreCase), limit, ignoreEmpty);
-		return splitIter.toList(mapping);
+		return toArray(split(str, separator));
 	}
 
 	/**
-	 * 切分字符串为字符串数组
+	 * 切分字符串，如果分隔符不存在则返回原字符串

+	 * 此方法不会去除切分字符串后每个元素两边的空格，不忽略空串
 	 *
-	 * @param str         被切分的字符串
-	 * @param separator   分隔符字符
-	 * @param limit       限制分片数，小于等于0表示无限制
-	 * @param isTrim      是否去除切分字符串后每个元素两边的空格
-	 * @param ignoreEmpty 是否忽略空串
-	 * @return 切分后的集合
-	 * @since 3.0.8
+	 * @param str       被切分的字符串
+	 * @param separator 分隔符
+	 * @return 字符串
 	 */
-	public static String[] splitToArray(final CharSequence str, final char separator, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
-		return toArray(split(str, separator, limit, isTrim, ignoreEmpty));
+	public static List split(final CharSequence str, final CharSequence separator) {
+		return split(str, separator, false, false);
 	}
 
-	//---------------------------------------------------------------------------------------------- Split by String
-
 	/**
 	 * 切分字符串，不忽略大小写
 	 *
@@ -226,21 +93,9 @@ public class SplitUtil {
 	 * @return 切分后的集合
 	 * @since 3.0.8
 	 */
-	public static List split(final CharSequence str, final String separator, final boolean isTrim, final boolean ignoreEmpty) {
-		return split(str, separator, -1, isTrim, ignoreEmpty, false);
-	}
-
-	/**
-	 * 切分字符串，去除每个元素两边空格，不忽略大小写
-	 *
-	 * @param str         被切分的字符串
-	 * @param separator   分隔符字符串
-	 * @param ignoreEmpty 是否忽略空串
-	 * @return 切分后的集合
-	 * @since 3.2.1
-	 */
-	public static List splitTrim(final CharSequence str, final String separator, final boolean ignoreEmpty) {
-		return split(str, separator, true, ignoreEmpty);
+	public static List split(final CharSequence str, final CharSequence separator,
+									 final boolean isTrim, final boolean ignoreEmpty) {
+		return split(str, separator, UNLIMITED, isTrim, ignoreEmpty, false);
 	}
 
 	/**
@@ -254,109 +109,127 @@ public class SplitUtil {
 	 * @return 切分后的集合
 	 * @since 3.0.8
 	 */
-	public static List split(final CharSequence str, final String separator, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
+	public static List split(final CharSequence str, final CharSequence separator,
+									 final int limit, final boolean isTrim, final boolean ignoreEmpty) {
 		return split(str, separator, limit, isTrim, ignoreEmpty, false);
 	}
 
-	/**
-	 * 切分字符串，去除每个元素两边空格，不忽略大小写
-	 *
-	 * @param str         被切分的字符串
-	 * @param separator   分隔符字符串
-	 * @param limit       限制分片数，小于等于0表示无限制
-	 * @param ignoreEmpty 是否忽略空串
-	 * @return 切分后的集合
-	 * @since 3.2.1
-	 */
-	public static List splitTrim(final CharSequence str, final String separator, final int limit, final boolean ignoreEmpty) {
-		return split(str, separator, limit, true, ignoreEmpty);
-	}
-
-	/**
-	 * 切分字符串，忽略大小写
-	 *
-	 * @param str         被切分的字符串
-	 * @param separator   分隔符字符串
-	 * @param limit       限制分片数，小于等于0表示无限制
-	 * @param isTrim      是否去除切分字符串后每个元素两边的空格
-	 * @param ignoreEmpty 是否忽略空串
-	 * @return 切分后的集合
-	 * @since 3.2.1
-	 */
-	public static List splitIgnoreCase(final CharSequence str, final String separator, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
-		return split(str, separator, limit, isTrim, ignoreEmpty, true);
-	}
-
-	/**
-	 * 切分字符串，去除每个元素两边空格，忽略大小写
-	 *
-	 * @param str         被切分的字符串
-	 * @param separator   分隔符字符串
-	 * @param limit       限制分片数，小于等于0表示无限制
-	 * @param ignoreEmpty 是否忽略空串
-	 * @return 切分后的集合
-	 * @since 3.2.1
-	 */
-	public static List splitTrimIgnoreCase(final CharSequence str, final String separator, final int limit, final boolean ignoreEmpty) {
-		return split(str, separator, limit, true, ignoreEmpty, true);
-	}
-
 	/**
 	 * 切分字符串

 	 * 如果提供的字符串为{@code null}，则返回一个空的{@link ArrayList}

 	 * 如果提供的字符串为""，则当ignoreEmpty时返回空的{@link ArrayList}，否则返回只有一个""元素的{@link ArrayList}
 	 *
-	 * @param text        被切分的字符串
+	 * @param str         被切分的字符串
 	 * @param separator   分隔符字符串
 	 * @param limit       限制分片数，小于等于0表示无限制
 	 * @param isTrim      是否去除切分字符串后每个元素两边的空格
 	 * @param ignoreEmpty 是否忽略空串
 	 * @param ignoreCase  是否忽略大小写
 	 * @return 切分后的集合
-	 * @since 3.2.1
 	 */
-	public static List split(final CharSequence text, final String separator, final int limit, final boolean isTrim, final boolean ignoreEmpty, final boolean ignoreCase) {
-		if(null == text){
-			return new ArrayList<>(0);
-		} else if (0 == text.length()) {
-			return ignoreEmpty ? new ArrayList<>(0) : ListUtil.of(StrUtil.EMPTY);
-		}
-		final SplitIter splitIter = new SplitIter(text, StrFinder.of(separator, ignoreCase), limit, ignoreEmpty);
-		return splitIter.toList(isTrim);
+	public static List split(final CharSequence str, final CharSequence separator,
+									 final int limit, final boolean isTrim, final boolean ignoreEmpty, final boolean ignoreCase) {
+		return split(str, separator, limit, ignoreEmpty, ignoreCase, trimFunc(isTrim));
 	}
 
 	/**
-	 * 切分字符串为字符串数组
+	 * 切分字符串

+	 * 如果提供的字符串为{@code null}，则返回一个空的{@link ArrayList}

+	 * 如果提供的字符串为""，则当ignoreEmpty时返回空的{@link ArrayList}，否则返回只有一个""元素的{@link ArrayList}
 	 *
+	 * @param          元素类型
 	 * @param str         被切分的字符串
-	 * @param separator   分隔符字符
+	 * @param separator   分隔符字符串
 	 * @param limit       限制分片数，小于等于0表示无限制
-	 * @param isTrim      是否去除切分字符串后每个元素两边的空格
 	 * @param ignoreEmpty 是否忽略空串
+	 * @param ignoreCase  是否忽略大小写
+	 * @param mapping     切分后字段映射函数
+	 * @return 切分后的集合
+	 */
+	public static  List split(final CharSequence str, final CharSequence separator,
+									final int limit, final boolean ignoreEmpty, final boolean ignoreCase,
+									final Function mapping) {
+		if (null == str) {
+			return ListUtil.zero();
+		} else if (0 == str.length() && ignoreEmpty) {
+			return ListUtil.zero();
+		}
+		Assert.notEmpty(separator, "Separator must be not empty!");
+
+		// 查找分隔符的方式
+		final TextFinder finder = separator.length() == 1 ?
+				new CharFinder(separator.charAt(0), ignoreCase) :
+				StrFinder.of(separator, ignoreCase);
+
+		final SplitIter splitIter = new SplitIter(str, finder, limit, ignoreEmpty);
+		return splitIter.toList(mapping);
+	}
+	// endregion
+
+	// region ----- Split by XXX
+
+	/**
+	 * 切分路径字符串

+	 * 如果为空字符串或者null 则返回空集合


+	 * 空路径会被忽略
+	 *
+	 * @param str 被切分的字符串
+	 * @return 切分后的集合
+	 */
+	public static List splitPath(final CharSequence str) {
+		return splitPath(str, UNLIMITED);
+	}
+
+	/**
+	 * 切分路径字符串

+	 * 如果为空字符串或者null 则返回空集合

+	 * 空路径会被忽略
+	 *
+	 * @param str   被切分的字符串
+	 * @param limit 限制分片数，小于等于0表示无限制
 	 * @return 切分后的集合
 	 * @since 3.0.8
 	 */
-	public static String[] splitToArray(final CharSequence str, final String separator, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
-		return toArray(split(str, separator, limit, isTrim, ignoreEmpty));
-	}
+	public static List splitPath(final CharSequence str, final int limit) {
+		if (StrUtil.isBlank(str)) {
+			return ListUtil.zero();
+		}
 
-	//---------------------------------------------------------------------------------------------- Split by Whitespace
+		final SplitIter splitIter = new SplitIter(str,
+				new CharMatcherFinder(
+						(c) -> c == CharUtil.SLASH || c == CharUtil.BACKSLASH),
+				// 路径中允许空格
+				limit, true);
+		return splitIter.toList(false);
+	}
 
 	/**
 	 * 使用空白符切分字符串

 	 * 切分后的字符串两边不包含空白符，空串或空白符串并不做为元素之一

 	 * 如果为空字符串或者null 则返回空集合
 	 *
-	 * @param text  被切分的字符串
+	 * @param str 被切分的字符串
+	 * @return 切分后的集合
+	 */
+	public static List splitByBlank(final CharSequence str) {
+		return splitByBlank(str, UNLIMITED);
+	}
+
+	/**
+	 * 使用空白符切分字符串

+	 * 切分后的字符串两边不包含空白符，空串或空白符串并不做为元素之一

+	 * 如果为空字符串或者null 则返回空集合
+	 *
+	 * @param str   被切分的字符串
 	 * @param limit 限制分片数，小于等于0表示无限制
 	 * @return 切分后的集合
 	 * @since 3.0.8
 	 */
-	public static List split(final CharSequence text, final int limit) {
-		if (StrUtil.isBlank(text)) {
-			return new ArrayList<>(0);
+	public static List splitByBlank(final CharSequence str, final int limit) {
+		if (StrUtil.isBlank(str)) {
+			return ListUtil.zero();
 		}
-		final SplitIter splitIter = new SplitIter(text, new CharMatcherFinder(CharUtil::isBlankChar), limit, true);
+		final SplitIter splitIter = new SplitIter(str, new CharMatcherFinder(CharUtil::isBlankChar), limit, true);
 		return splitIter.toList(false);
 	}
 
@@ -368,15 +241,14 @@ public class SplitUtil {
 	 * @return 切分后的集合
 	 * @since 3.0.8
 	 */
-	public static String[] splitToArray(final CharSequence str, final int limit) {
-		return toArray(split(str, limit));
+	public static String[] splitByBlankToArray(final CharSequence str, final int limit) {
+		return toArray(splitByBlank(str, limit));
 	}
-	//---------------------------------------------------------------------------------------------- Split by regex
 
 	/**
 	 * 通过正则切分字符串
 	 *
-	 * @param text           字符串
+	 * @param str            字符串
 	 * @param separatorRegex 分隔符正则
 	 * @param limit          限制分片数，小于等于0表示无限制
 	 * @param isTrim         是否去除切分字符串后每个元素两边的空格
@@ -384,16 +256,16 @@ public class SplitUtil {
 	 * @return 切分后的集合
 	 * @since 3.0.8
 	 */
-	public static List splitByRegex(final CharSequence text, final String separatorRegex, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
+	public static List splitByRegex(final CharSequence str, final String separatorRegex, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
 		final Pattern pattern = PatternPool.get(separatorRegex);
-		return split(text, pattern, limit, isTrim, ignoreEmpty);
+		return splitByRegex(str, pattern, limit, isTrim, ignoreEmpty);
 	}
 
 	/**
 	 * 通过正则切分字符串

 	 * 如果为空字符串或者null 则返回空集合
 	 *
-	 * @param text             字符串
+	 * @param str              字符串
 	 * @param separatorPattern 分隔符正则{@link Pattern}
 	 * @param limit            限制分片数，小于等于0表示无限制
 	 * @param isTrim           是否去除切分字符串后每个元素两边的空格
@@ -401,11 +273,11 @@ public class SplitUtil {
 	 * @return 切分后的集合
 	 * @since 3.0.8
 	 */
-	public static List split(final CharSequence text, final Pattern separatorPattern, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
-		if (StrUtil.isEmpty(text)) {
-			return new ArrayList<>(0);
+	public static List splitByRegex(final CharSequence str, final Pattern separatorPattern, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
+		if (StrUtil.isEmpty(str)) {
+			return ListUtil.zero();
 		}
-		final SplitIter splitIter = new SplitIter(text, new PatternFinder(separatorPattern), limit, ignoreEmpty);
+		final SplitIter splitIter = new SplitIter(str, new PatternFinder(separatorPattern), limit, ignoreEmpty);
 		return splitIter.toList(isTrim);
 	}
 
@@ -420,26 +292,25 @@ public class SplitUtil {
 	 * @return 切分后的集合
 	 * @since 3.0.8
 	 */
-	public static String[] splitToArray(final CharSequence str, final Pattern separatorPattern, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
-		return toArray(split(str, separatorPattern, limit, isTrim, ignoreEmpty));
+	public static String[] splitByRegexToArray(final CharSequence str, final Pattern separatorPattern, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
+		return toArray(splitByRegex(str, separatorPattern, limit, isTrim, ignoreEmpty));
 	}
-	//---------------------------------------------------------------------------------------------- Split by length
 
 	/**
 	 * 根据给定长度，将给定字符串截取为多个部分
 	 *
-	 * @param text 字符串
-	 * @param len  每一个小节的长度，必须大于0
+	 * @param str 字符串
+	 * @param len 每一个小节的长度，必须大于0
 	 * @return 截取后的字符串数组
 	 */
-	public static String[] splitByLength(final CharSequence text, final int len) {
-		if (StrUtil.isEmpty(text)) {
+	public static String[] splitByLength(final CharSequence str, final int len) {
+		if (StrUtil.isEmpty(str)) {
 			return new String[0];
 		}
-		final SplitIter splitIter = new SplitIter(text, new LengthFinder(len), -1, false);
+		final SplitIter splitIter = new SplitIter(str, new LengthFinder(len), -1, false);
 		return splitIter.toArray(false);
 	}
-	//---------------------------------------------------------------------------------------------------------- Private method start
+	// endregion
 
 	/**
 	 * List转Array
diff --git a/hutool-core/src/test/java/cn/hutool/core/codec/hash/SimhashTest.java b/hutool-core/src/test/java/cn/hutool/core/codec/hash/SimhashTest.java
index e1369973b..0c7703c7b 100644
--- a/hutool-core/src/test/java/cn/hutool/core/codec/hash/SimhashTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/codec/hash/SimhashTest.java
@@ -1,6 +1,7 @@
 package cn.hutool.core.codec.hash;
 
 import cn.hutool.core.text.StrUtil;
+import cn.hutool.core.text.split.SplitUtil;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -12,11 +13,11 @@ public class SimhashTest {
 		final String text2 = "我是 一个 普通 字符串";
 
 		final Simhash simhash = new Simhash();
-		final long hash = simhash.hash64(StrUtil.split(text1, ' '));
+		final long hash = simhash.hash64(SplitUtil.split(text1, StrUtil.SPACE));
 		Assert.assertTrue(hash != 0);
 
 		simhash.store(hash);
-		final boolean duplicate = simhash.equals(StrUtil.split(text2, ' '));
+		final boolean duplicate = simhash.equals(SplitUtil.split(text2, StrUtil.SPACE));
 		Assert.assertTrue(duplicate);
 	}
 }
diff --git a/hutool-core/src/test/java/cn/hutool/core/text/SplitUtilTest.java b/hutool-core/src/test/java/cn/hutool/core/text/SplitUtilTest.java
index 096f26bd3..5c004f1bd 100755
--- a/hutool-core/src/test/java/cn/hutool/core/text/SplitUtilTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/text/SplitUtilTest.java
@@ -4,6 +4,8 @@ import cn.hutool.core.text.split.SplitUtil;
 import org.junit.Assert;
 import org.junit.Test;
 
+import java.util.List;
+
 public class SplitUtilTest {
 
 	@Test
@@ -12,4 +14,52 @@ public class SplitUtilTest {
 		Assert.assertThrows(IllegalArgumentException.class, () -> SplitUtil.splitByLength("test length 0", 0));
 	}
 
+	@Test
+	public void splitToLongTest() {
+		final String str = "1,2,3,4, 5";
+		long[] longArray = SplitUtil.splitTo(str, ",", long[].class);
+		Assert.assertArrayEquals(new long[]{1, 2, 3, 4, 5}, longArray);
+
+		longArray = SplitUtil.splitTo(str, ",", long[].class);
+		Assert.assertArrayEquals(new long[]{1, 2, 3, 4, 5}, longArray);
+	}
+
+	@Test
+	public void splitToIntTest() {
+		final String str = "1,2,3,4, 5";
+		int[] intArray = SplitUtil.splitTo(str, ",", int[].class);
+		Assert.assertArrayEquals(new int[]{1, 2, 3, 4, 5}, intArray);
+
+		intArray = SplitUtil.splitTo(str, ",", int[].class);
+		Assert.assertArrayEquals(new int[]{1, 2, 3, 4, 5}, intArray);
+	}
+
+	@Test
+	public void splitTest() {
+		final String str = "a,b ,c,d,,e";
+		final List split = SplitUtil.split(str, ",", -1, true, true);
+		// 测试空是否被去掉
+		Assert.assertEquals(5, split.size());
+		// 测试去掉两边空白符是否生效
+		Assert.assertEquals("b", split.get(1));
+
+		final String[] strings = SplitUtil.splitToArray("abc/", StrUtil.SLASH);
+		Assert.assertEquals(2, strings.length);
+	}
+
+	@Test
+	public void splitEmptyTest() {
+		final String str = "";
+		final List split = SplitUtil.split(str, ",", -1, true, true);
+		// 测试空是否被去掉
+		Assert.assertEquals(0, split.size());
+	}
+
+	@Test
+	public void splitToArrayNullTest() {
+		final String[] strings = SplitUtil.splitToArray(null, ".");
+		Assert.assertNotNull(strings);
+		Assert.assertEquals(0, strings.length);
+	}
+
 }
diff --git a/hutool-core/src/test/java/cn/hutool/core/text/StrRepeaterTest.java b/hutool-core/src/test/java/cn/hutool/core/text/StrRepeaterTest.java
new file mode 100644
index 000000000..8187727fd
--- /dev/null
+++ b/hutool-core/src/test/java/cn/hutool/core/text/StrRepeaterTest.java
@@ -0,0 +1,21 @@
+package cn.hutool.core.text;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class StrRepeaterTest {
+
+	@Test
+	public void repeatByLengthTest() {
+		// 如果指定长度非指定字符串的整数倍，截断到固定长度
+		final String ab = StrRepeater.of(5).repeatByLength("ab");
+		Assert.assertEquals("ababa", ab);
+	}
+
+	@Test
+	public void repeatByLengthTest2() {
+		// 如果指定长度小于字符串本身的长度，截断之
+		final String ab = StrRepeater.of(2).repeatByLength("abcde");
+		Assert.assertEquals("ab", ab);
+	}
+}
diff --git a/hutool-core/src/test/java/cn/hutool/core/text/StrUtilTest.java b/hutool-core/src/test/java/cn/hutool/core/text/StrUtilTest.java
index ccbc3fd4f..66015f20d 100644
--- a/hutool-core/src/test/java/cn/hutool/core/text/StrUtilTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/text/StrUtilTest.java
@@ -1,6 +1,7 @@
 package cn.hutool.core.text;
 
 import cn.hutool.core.map.Dict;
+import cn.hutool.core.text.split.SplitUtil;
 import cn.hutool.core.util.CharUtil;
 import cn.hutool.core.util.RandomUtil;
 import org.junit.Assert;
@@ -61,31 +62,10 @@ public class StrUtilTest {
 		Assert.assertArrayEquals(new String[]{"aaab", "bbcc", "cddd", "aadf", "dfsd", "fsdf", "0"}, cut);
 	}
 
-	@Test
-	public void splitTest() {
-		final String str = "a,b ,c,d,,e";
-		final List split = StrUtil.split(str, ',', -1, true, true);
-		// 测试空是否被去掉
-		Assert.assertEquals(5, split.size());
-		// 测试去掉两边空白符是否生效
-		Assert.assertEquals("b", split.get(1));
-
-		final String[] strings = StrUtil.splitToArray("abc/", '/');
-		Assert.assertEquals(2, strings.length);
-	}
-
-	@Test
-	public void splitEmptyTest() {
-		final String str = "";
-		final List split = StrUtil.split(str, ',', -1, true, true);
-		// 测试空是否被去掉
-		Assert.assertEquals(0, split.size());
-	}
-
 	@Test
 	public void splitTest2() {
 		final String str = "a.b.";
-		final List split = StrUtil.split(str, '.');
+		final List split = SplitUtil.split(str, ".");
 		Assert.assertEquals(3, split.size());
 		Assert.assertEquals("b", split.get(1));
 		Assert.assertEquals("", split.get(2));
@@ -93,32 +73,7 @@ public class StrUtilTest {
 
 	@Test
 	public void splitNullTest() {
-		Assert.assertEquals(0, StrUtil.split(null, '.').size());
-	}
-
-	@Test(expected = IllegalArgumentException.class)
-	public void splitToArrayNullTest() {
-		StrUtil.splitToArray(null, '.');
-	}
-
-	@Test
-	public void splitToLongTest() {
-		final String str = "1,2,3,4, 5";
-		long[] longArray = StrUtil.splitToLong(str, ',');
-		Assert.assertArrayEquals(new long[]{1, 2, 3, 4, 5}, longArray);
-
-		longArray = StrUtil.splitToLong(str, ",");
-		Assert.assertArrayEquals(new long[]{1, 2, 3, 4, 5}, longArray);
-	}
-
-	@Test
-	public void splitToIntTest() {
-		final String str = "1,2,3,4, 5";
-		int[] intArray = StrUtil.splitToInt(str, ',');
-		Assert.assertArrayEquals(new int[]{1, 2, 3, 4, 5}, intArray);
-
-		intArray = StrUtil.splitToInt(str, ",");
-		Assert.assertArrayEquals(new int[]{1, 2, 3, 4, 5}, intArray);
+		Assert.assertEquals(0, SplitUtil.split(null, ".").size());
 	}
 
 	@Test
@@ -576,10 +531,10 @@ public class StrUtilTest {
 
 	@Test
 	public void wrapAllTest() {
-		String[] strings = StrUtil.wrapAll("`", "`", StrUtil.splitToArray("1,2,3,4", ','));
+		String[] strings = StrUtil.wrapAll("`", "`", SplitUtil.splitToArray("1,2,3,4", ","));
 		Assert.assertEquals("[`1`, `2`, `3`, `4`]", StrUtil.utf8Str(strings));
 
-		strings = StrUtil.wrapAllWithPair("`", StrUtil.splitToArray("1,2,3,4", ','));
+		strings = StrUtil.wrapAllWithPair("`", SplitUtil.splitToArray("1,2,3,4", ","));
 		Assert.assertEquals("[`1`, `2`, `3`, `4`]", StrUtil.utf8Str(strings));
 	}
 
diff --git a/hutool-core/src/test/java/cn/hutool/core/text/split/StrSplitterTest.java b/hutool-core/src/test/java/cn/hutool/core/text/split/StrSplitterTest.java
index 69a059374..5d7433bd9 100644
--- a/hutool-core/src/test/java/cn/hutool/core/text/split/StrSplitterTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/text/split/StrSplitterTest.java
@@ -1,6 +1,5 @@
 package cn.hutool.core.text.split;
 
-import cn.hutool.core.lang.Console;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -16,7 +15,7 @@ public class StrSplitterTest {
 	@Test
 	public void splitByCharTest(){
 		final String str1 = "a, ,efedsfs,   ddf";
-		final List split = SplitUtil.split(str1, ',', 0, true, true);
+		final List split = SplitUtil.split(str1, ",", 0, true, true);
 
 		Assert.assertEquals("ddf", split.get(2));
 		Assert.assertEquals(3, split.size());
@@ -33,15 +32,15 @@ public class StrSplitterTest {
 	@Test
 	public void splitByBlankTest(){
 		final String str1 = "aa bbccaa     ddaaee";
-		final List split = SplitUtil.split(str1, 0);
+		final List split = SplitUtil.splitByBlank(str1);
 		Assert.assertEquals("ddaaee", split.get(2));
 		Assert.assertEquals(3, split.size());
 	}
 
 	@Test
 	public void splitPathTest(){
-		final String str1 = "/use/local/bin";
-		final List split = SplitUtil.splitPath(str1, 0);
+		final String str1 = "/use/local\\bin";
+		final List split = SplitUtil.splitPath(str1);
 		Assert.assertEquals("bin", split.get(2));
 		Assert.assertEquals(3, split.size());
 	}
@@ -49,22 +48,25 @@ public class StrSplitterTest {
 	@Test
 	public void splitMappingTest() {
 		final String str = "1.2.";
-		final List split = SplitUtil.split(str, '.', 0, true, true, Long::parseLong);
+		final List split = SplitUtil.split(str, ".", 0, true, true, Long::parseLong);
 		Assert.assertEquals(2, split.size());
 		Assert.assertEquals(Long.valueOf(1L), split.get(0));
 		Assert.assertEquals(Long.valueOf(2L), split.get(1));
 	}
 
+	@SuppressWarnings("MismatchedReadAndWriteOfArray")
 	@Test
 	public void splitEmptyTest(){
 		final String str = "";
 		final String[] split = str.split(",");
-		final String[] strings = SplitUtil.splitToArray(str, ",", -1, false, false);
+		final String[] strings = SplitUtil.split(str, ",", -1, false, false)
+				.toArray(new String[0]);
 
 		Assert.assertNotNull(strings);
 		Assert.assertArrayEquals(split, strings);
 
-		final String[] strings2 = SplitUtil.splitToArray(str, ",", -1, false, true);
+		final String[] strings2 = SplitUtil.split(str, ",", -1, false, true)
+				.toArray(new String[0]);
 		Assert.assertEquals(0, strings2.length);
 	}
 
@@ -72,11 +74,13 @@ public class StrSplitterTest {
 	@Test
 	public void splitNullTest(){
 		final String str = null;
-		final String[] strings = SplitUtil.splitToArray(str, ",", -1, false, false);
+		final String[] strings = SplitUtil.split(str, ",", -1, false, false)
+				.toArray(new String[0]);
 		Assert.assertNotNull(strings);
 		Assert.assertEquals(0, strings.length);
 
-		final String[] strings2 = SplitUtil.splitToArray(str, ",", -1, false, true);
+		final String[] strings2 = SplitUtil.split(str, ",", -1, false, true)
+				.toArray(new String[0]);
 		Assert.assertNotNull(strings2);
 		Assert.assertEquals(0, strings2.length);
 	}
diff --git a/hutool-cron/src/main/java/cn/hutool/cron/pattern/parser/PartParser.java b/hutool-cron/src/main/java/cn/hutool/cron/pattern/parser/PartParser.java
index ce3c10784..fe3b57928 100644
--- a/hutool-cron/src/main/java/cn/hutool/cron/pattern/parser/PartParser.java
+++ b/hutool-cron/src/main/java/cn/hutool/cron/pattern/parser/PartParser.java
@@ -5,14 +5,10 @@ import cn.hutool.core.date.Month;
 import cn.hutool.core.date.Week;
 import cn.hutool.core.math.NumberUtil;
 import cn.hutool.core.text.StrUtil;
-import cn.hutool.core.util.CharUtil;
+import cn.hutool.core.text.split.SplitUtil;
 import cn.hutool.cron.CronException;
 import cn.hutool.cron.pattern.Part;
-import cn.hutool.cron.pattern.matcher.AlwaysTrueMatcher;
-import cn.hutool.cron.pattern.matcher.BoolArrayMatcher;
-import cn.hutool.cron.pattern.matcher.DayOfMonthMatcher;
-import cn.hutool.cron.pattern.matcher.PartMatcher;
-import cn.hutool.cron.pattern.matcher.YearValueMatcher;
+import cn.hutool.cron.pattern.matcher.*;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -103,7 +99,7 @@ public class PartParser {
 	private List parseArray(final String value) {
 		final List values = new ArrayList<>();
 
-		final List parts = StrUtil.split(value, CharUtil.COMMA);
+		final List parts = SplitUtil.split(value, StrUtil.COMMA);
 		for (final String part : parts) {
 			ListUtil.addAllIfNotContains(values, parseStep(part));
 		}
@@ -123,7 +119,7 @@ public class PartParser {
 	 * @return List
 	 */
 	private List parseStep(final String value) {
-		final List parts = StrUtil.split(value, CharUtil.SLASH);
+		final List parts = SplitUtil.split(value, StrUtil.SLASH);
 		final int size = parts.size();
 
 		final List results;
@@ -187,7 +183,7 @@ public class PartParser {
 		}
 
 		//Range模式
-		final List parts = StrUtil.split(value, '-');
+		final List parts = SplitUtil.split(value, StrUtil.DASHED);
 		final int size = parts.size();
 		if (size == 1) {// 普通值
 			final int v1 = parseNumber(value);
diff --git a/hutool-cron/src/main/java/cn/hutool/cron/pattern/parser/PatternParser.java b/hutool-cron/src/main/java/cn/hutool/cron/pattern/parser/PatternParser.java
index 79b14ab9e..d04110d5c 100644
--- a/hutool-cron/src/main/java/cn/hutool/cron/pattern/parser/PatternParser.java
+++ b/hutool-cron/src/main/java/cn/hutool/cron/pattern/parser/PatternParser.java
@@ -1,7 +1,7 @@
 package cn.hutool.cron.pattern.parser;
 
 import cn.hutool.core.lang.Assert;
-import cn.hutool.core.text.StrUtil;
+import cn.hutool.core.text.split.SplitUtil;
 import cn.hutool.cron.CronException;
 import cn.hutool.cron.pattern.Part;
 import cn.hutool.cron.pattern.matcher.AlwaysTrueMatcher;
@@ -47,7 +47,7 @@ public class PatternParser {
 	 * @return {@link List}
 	 */
 	private static List parseGroupPattern(final String groupPattern) {
-		final List patternList = StrUtil.splitTrim(groupPattern, '|');
+		final List patternList = SplitUtil.splitTrim(groupPattern, "|");
 		final List patternMatchers = new ArrayList<>(patternList.size());
 		for (final String pattern : patternList) {
 			patternMatchers.add(parseSingle(pattern));
diff --git a/hutool-db/src/main/java/cn/hutool/db/sql/Condition.java b/hutool-db/src/main/java/cn/hutool/db/sql/Condition.java
index 3c2da0a6b..f577bd2c3 100644
--- a/hutool-db/src/main/java/cn/hutool/db/sql/Condition.java
+++ b/hutool-db/src/main/java/cn/hutool/db/sql/Condition.java
@@ -426,11 +426,11 @@ public class Condition implements Cloneable, Serializable {
 				// pr#2046@Github
 				valuesForIn = (Collection) value;
 			} else if (value instanceof CharSequence) {
-				valuesForIn = StrUtil.split((CharSequence) value, ',');
+				valuesForIn = SplitUtil.split((CharSequence) value, StrUtil.COMMA);
 			} else {
 				valuesForIn = Arrays.asList(Convert.convert(Object[].class, value));
 			}
-			conditionStrBuilder.append(StrUtil.repeatAndJoin("?", valuesForIn.size(), ","));
+			conditionStrBuilder.append(StrUtil.repeatAndJoin("?", valuesForIn.size(), StrUtil.COMMA));
 			if (null != paramValues) {
 				paramValues.addAll(valuesForIn);
 			}
@@ -490,13 +490,13 @@ public class Condition implements Cloneable, Serializable {
 			}
 		}
 
-		final List strs = StrUtil.split(valueStr, CharUtil.SPACE, 2);
+		final List strs = SplitUtil.split(valueStr, StrUtil.SPACE, 2, true, false);
 		if (strs.size() < 2) {
 			return;
 		}
 
 		// 处理常用符号和IN
-		final String firstPart = strs.get(0).trim().toUpperCase();
+		final String firstPart = strs.get(0).toUpperCase();
 		if (OPERATORS.contains(firstPart)) {
 			this.operator = firstPart;
 			// 比较符号后跟大部分为数字，此处做转换（IN不做转换）
@@ -514,7 +514,8 @@ public class Condition implements Cloneable, Serializable {
 
 		// 处理BETWEEN x AND y
 		if (OPERATOR_BETWEEN.equals(firstPart)) {
-			final List betweenValueStrs = SplitUtil.splitTrimIgnoreCase(strs.get(1), LogicalOperator.AND.toString(), 2, true);
+			final List betweenValueStrs = SplitUtil.split(strs.get(1), LogicalOperator.AND.toString(),
+					2, true, true, true);
 			if (betweenValueStrs.size() < 2) {
 				// 必须满足a AND b格式，不满足被当作普通值
 				return;
@@ -532,11 +533,10 @@ public class Condition implements Cloneable, Serializable {
 	 * @param value 值
 	 * @return 去掉引号后的值
 	 */
-	private static String unwrapQuote(String value) {
+	private static String unwrapQuote(final String value) {
 		if (null == value) {
 			return null;
 		}
-		value = value.trim();
 
 		int from = 0;
 		int to = value.length();
@@ -562,8 +562,7 @@ public class Condition implements Cloneable, Serializable {
 	 * @param value 被转换的字符串值
 	 * @return 转换后的值
 	 */
-	private static Object tryToNumber(String value) {
-		value = StrUtil.trim(value);
+	private static Object tryToNumber(final String value) {
 		if (false == NumberUtil.isNumber(value)) {
 			return value;
 		}
diff --git a/hutool-db/src/main/java/cn/hutool/db/sql/QuoteWrapper.java b/hutool-db/src/main/java/cn/hutool/db/sql/QuoteWrapper.java
index 87b732857..c25302f25 100644
--- a/hutool-db/src/main/java/cn/hutool/db/sql/QuoteWrapper.java
+++ b/hutool-db/src/main/java/cn/hutool/db/sql/QuoteWrapper.java
@@ -2,8 +2,8 @@ package cn.hutool.db.sql;
 
 import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.text.StrUtil;
+import cn.hutool.core.text.split.SplitUtil;
 import cn.hutool.core.util.ArrayUtil;
-import cn.hutool.core.util.CharUtil;
 import cn.hutool.db.Entity;
 
 import java.io.Serializable;
@@ -115,7 +115,11 @@ public class QuoteWrapper implements Serializable {
 
 		//对于Oracle这类数据库，表名中包含用户名需要单独拆分包装
 		if (field.contains(StrUtil.DOT)) {
-			final Collection target = CollUtil.edit(StrUtil.split(field, CharUtil.DOT, 2), t -> StrUtil.format("{}{}{}", preWrapQuote, t, sufWrapQuote));
+			final Collection target = CollUtil.edit(
+					// 用户名和表名不能包含空格
+					SplitUtil.split(field, StrUtil.DOT, 2, true, false),
+					// 用户名和表名都加引号
+					t -> StrUtil.format("{}{}{}", preWrapQuote, t, sufWrapQuote));
 			return CollUtil.join(target, StrUtil.DOT);
 		}
 
diff --git a/hutool-db/src/test/java/cn/hutool/db/meta/MetaUtilTest.java b/hutool-db/src/test/java/cn/hutool/db/meta/MetaUtilTest.java
index 43f64eee2..c88ea9526 100644
--- a/hutool-db/src/test/java/cn/hutool/db/meta/MetaUtilTest.java
+++ b/hutool-db/src/test/java/cn/hutool/db/meta/MetaUtilTest.java
@@ -2,6 +2,7 @@ package cn.hutool.db.meta;
 
 import cn.hutool.core.collection.SetUtil;
 import cn.hutool.core.text.StrUtil;
+import cn.hutool.core.text.split.SplitUtil;
 import cn.hutool.db.ds.DSFactory;
 import org.junit.Assert;
 import org.junit.Test;
@@ -33,7 +34,7 @@ public class MetaUtilTest {
 	@Test
 	public void getColumnNamesTest() {
 		final String[] names = MetaUtil.getColumnNames(ds, "user");
-		Assert.assertArrayEquals(StrUtil.splitToArray("id,name,age,birthday,gender", ','), names);
+		Assert.assertArrayEquals(SplitUtil.splitToArray("id,name,age,birthday,gender", StrUtil.COMMA), names);
 	}
 
 	@Test
diff --git a/hutool-extra/src/main/java/cn/hutool/extra/mail/MailUtil.java b/hutool-extra/src/main/java/cn/hutool/extra/mail/MailUtil.java
index 12a5e42aa..1ac72b4b6 100644
--- a/hutool-extra/src/main/java/cn/hutool/extra/mail/MailUtil.java
+++ b/hutool-extra/src/main/java/cn/hutool/extra/mail/MailUtil.java
@@ -4,6 +4,7 @@ import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.collection.ListUtil;
 import cn.hutool.core.io.IoUtil;
 import cn.hutool.core.map.MapUtil;
+import cn.hutool.core.text.split.SplitUtil;
 import cn.hutool.core.util.CharUtil;
 import cn.hutool.core.text.StrUtil;
 
@@ -430,9 +431,9 @@ public class MailUtil {
 
 		final List result;
 		if (StrUtil.contains(addresses, CharUtil.COMMA)) {
-			result = StrUtil.splitTrim(addresses, CharUtil.COMMA);
+			result = SplitUtil.splitTrim(addresses, StrUtil.COMMA);
 		} else if (StrUtil.contains(addresses, ';')) {
-			result = StrUtil.splitTrim(addresses, ';');
+			result = SplitUtil.splitTrim(addresses, ";");
 		} else {
 			result = ListUtil.of(addresses);
 		}
diff --git a/hutool-extra/src/main/java/cn/hutool/extra/management/JavaRuntimeInfo.java b/hutool-extra/src/main/java/cn/hutool/extra/management/JavaRuntimeInfo.java
index 19a6e38ab..cf09e31ff 100644
--- a/hutool-extra/src/main/java/cn/hutool/extra/management/JavaRuntimeInfo.java
+++ b/hutool-extra/src/main/java/cn/hutool/extra/management/JavaRuntimeInfo.java
@@ -1,6 +1,6 @@
 package cn.hutool.extra.management;
 
-import cn.hutool.core.text.StrUtil;
+import cn.hutool.core.text.split.SplitUtil;
 import cn.hutool.core.util.SystemUtil;
 
 import java.io.Serializable;
@@ -8,7 +8,7 @@ import java.io.Serializable;
 /**
  * 代表当前运行的JRE的信息。
  */
-public class JavaRuntimeInfo implements Serializable{
+public class JavaRuntimeInfo implements Serializable {
 	private static final long serialVersionUID = 1L;
 
 	private final String JAVA_RUNTIME_NAME = SystemUtil.get("java.runtime.name", false);
@@ -24,6 +24,11 @@ public class JavaRuntimeInfo implements Serializable{
 
 	private final String SUN_ARCH_DATA_MODEL = SystemUtil.get("sun.arch.data.model", false);
 
+	/**
+	 * 获取JRE的classpath
+	 *
+	 * @return JRE的classpath
+	 */
 	public final String getSunBoothClassPath() {
 		return SUN_BOOT_CLASS_PATH;
 	}
@@ -45,7 +50,6 @@ public class JavaRuntimeInfo implements Serializable{
 	 * 

 	 *
 	 * @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
-	 *
 	 * @since Java 1.3
 	 */
 	public final String getName() {
@@ -60,7 +64,6 @@ public class JavaRuntimeInfo implements Serializable{
 	 * 

 	 *
 	 * @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
-	 *
 	 * @since Java 1.3
 	 */
 	public final String getVersion() {
@@ -75,7 +78,6 @@ public class JavaRuntimeInfo implements Serializable{
 	 * 

 	 *
 	 * @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
-	 *
 	 * @since Java 1.1
 	 */
 	public final String getHomeDir() {
@@ -90,7 +92,6 @@ public class JavaRuntimeInfo implements Serializable{
 	 * 

 	 *
 	 * @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
-	 *
 	 * @since Java 1.3
 	 */
 	public final String getExtDirs() {
@@ -105,7 +106,6 @@ public class JavaRuntimeInfo implements Serializable{
 	 * 

 	 *
 	 * @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
-	 *
 	 * @since Java 1.4
 	 */
 	public final String getEndorsedDirs() {
@@ -120,7 +120,6 @@ public class JavaRuntimeInfo implements Serializable{
 	 * 

 	 *
 	 * @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
-	 *
 	 * @since Java 1.1
 	 */
 	public final String getClassPath() {
@@ -135,11 +134,10 @@ public class JavaRuntimeInfo implements Serializable{
 	 * 

 	 *
 	 * @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
-	 *
 	 * @since Java 1.1
 	 */
 	public final String[] getClassPathArray() {
-		return StrUtil.splitToArray(getClassPath(), SystemUtil.get("path.separator", false));
+		return SplitUtil.splitToArray(getClassPath(), SystemUtil.get("path.separator", false));
 	}
 
 	/**
@@ -150,7 +148,6 @@ public class JavaRuntimeInfo implements Serializable{
 	 * 

 	 *
 	 * @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
-	 *
 	 * @since Java 1.1
 	 */
 	public final String getClassVersion() {
@@ -165,7 +162,6 @@ public class JavaRuntimeInfo implements Serializable{
 	 * 

 	 *
 	 * @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
-	 *
 	 */
 	public final String getLibraryPath() {
 		return JAVA_LIBRARY_PATH;
@@ -179,11 +175,9 @@ public class JavaRuntimeInfo implements Serializable{
 	 * 

 	 *
 	 * @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
-	 *
-	 *
 	 */
 	public final String[] getLibraryPathArray() {
-		return StrUtil.splitToArray(getLibraryPath(), SystemUtil.get("path.separator", false));
+		return SplitUtil.splitToArray(getLibraryPath(), SystemUtil.get("path.separator", false));
 	}
 
 	/**
@@ -194,8 +188,6 @@ public class JavaRuntimeInfo implements Serializable{
 	 * 

 	 *
 	 * @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
-	 *
-	 *
 	 */
 	public final String getProtocolPackages() {
 		return SystemUtil.get("java.protocol.handler.pkgs", true);
diff --git a/hutool-extra/src/main/java/cn/hutool/extra/pinyin/PinyinEngine.java b/hutool-extra/src/main/java/cn/hutool/extra/pinyin/PinyinEngine.java
index d2fd4a7dc..b3abdb8ac 100644
--- a/hutool-extra/src/main/java/cn/hutool/extra/pinyin/PinyinEngine.java
+++ b/hutool-extra/src/main/java/cn/hutool/extra/pinyin/PinyinEngine.java
@@ -2,6 +2,7 @@ package cn.hutool.extra.pinyin;
 
 import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.text.StrUtil;
+import cn.hutool.core.text.split.SplitUtil;
 
 import java.util.List;
 
@@ -49,7 +50,7 @@ public interface PinyinEngine {
 	 */
 	default String getFirstLetter(final String str, final String separator) {
 		final String splitSeparator = StrUtil.isEmpty(separator) ? "#" : separator;
-		final List split = StrUtil.split(getPinyin(str, splitSeparator), splitSeparator);
+		final List split = SplitUtil.split(getPinyin(str, splitSeparator), splitSeparator);
 		return CollUtil.join(split, separator, (s)->String.valueOf(s.length() > 0 ? s.charAt(0) : StrUtil.EMPTY));
 	}
 }
diff --git a/hutool-http/src/main/java/cn/hutool/http/webservice/SoapClient.java b/hutool-http/src/main/java/cn/hutool/http/webservice/SoapClient.java
index f36433fdb..896e2d582 100644
--- a/hutool-http/src/main/java/cn/hutool/http/webservice/SoapClient.java
+++ b/hutool-http/src/main/java/cn/hutool/http/webservice/SoapClient.java
@@ -4,6 +4,7 @@ import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.io.IoUtil;
 import cn.hutool.core.map.MapUtil;
 import cn.hutool.core.text.StrUtil;
+import cn.hutool.core.text.split.SplitUtil;
 import cn.hutool.core.util.CharsetUtil;
 import cn.hutool.core.util.ObjUtil;
 import cn.hutool.core.util.XmlUtil;
@@ -398,7 +399,7 @@ public class SoapClient implements HeaderOperation {
 	 * @return this
 	 */
 	public SoapClient setMethod(final String methodName, final String namespaceURI) {
-		final List methodNameList = StrUtil.split(methodName, ':');
+		final List methodNameList = SplitUtil.split(methodName, StrUtil.COLON);
 		final QName qName;
 		if (2 == methodNameList.size()) {
 			qName = new QName(namespaceURI, methodNameList.get(1), methodNameList.get(0));
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 5c8bb7ce2..75c3518c9 100755
--- a/hutool-json/src/main/java/cn/hutool/json/InternalJSONUtil.java
+++ b/hutool-json/src/main/java/cn/hutool/json/InternalJSONUtil.java
@@ -12,6 +12,7 @@ import cn.hutool.core.reflect.ClassUtil;
 import cn.hutool.core.reflect.ConstructorUtil;
 import cn.hutool.core.reflect.TypeUtil;
 import cn.hutool.core.text.StrUtil;
+import cn.hutool.core.text.split.SplitUtil;
 import cn.hutool.core.util.ArrayUtil;
 import cn.hutool.core.util.CharUtil;
 import cn.hutool.core.util.ObjUtil;
@@ -210,7 +211,7 @@ public final class InternalJSONUtil {
 	 * @param predicate  属性过滤器，{@link Predicate#test(Object)}为{@code true}保留
 	 */
 	public static void propertyPut(final JSONObject jsonObject, final Object key, final Object value, final Predicate> predicate) {
-		final String[] path = StrUtil.splitToArray(Convert.toStr(key), CharUtil.DOT);
+		final String[] path = SplitUtil.splitToArray(Convert.toStr(key), StrUtil.DOT);
 		final int last = path.length - 1;
 		JSONObject target = jsonObject;
 		for (int i = 0; i < last; i += 1) {
diff --git a/hutool-json/src/main/java/cn/hutool/json/jwt/JWT.java b/hutool-json/src/main/java/cn/hutool/json/jwt/JWT.java
index 5cf7f63f3..3dd257b44 100755
--- a/hutool-json/src/main/java/cn/hutool/json/jwt/JWT.java
+++ b/hutool-json/src/main/java/cn/hutool/json/jwt/JWT.java
@@ -6,7 +6,7 @@ import cn.hutool.core.date.DateUtil;
 import cn.hutool.core.exceptions.ValidateException;
 import cn.hutool.core.lang.Assert;
 import cn.hutool.core.text.StrUtil;
-import cn.hutool.core.util.CharUtil;
+import cn.hutool.core.text.split.SplitUtil;
 import cn.hutool.core.util.CharsetUtil;
 import cn.hutool.json.JSONObject;
 import cn.hutool.json.jwt.signers.AlgorithmUtil;
@@ -423,7 +423,7 @@ public class JWT implements RegisteredPayload {
 	 * @return 三部分内容
 	 */
 	private static List splitToken(final String token) {
-		final List tokens = StrUtil.split(token, CharUtil.DOT);
+		final List tokens = SplitUtil.split(token, StrUtil.DOT);
 		if (3 != tokens.size()) {
 			throw new JWTException("The token was expected 3 parts, but got {}.", tokens.size());
 		}
diff --git a/hutool-setting/src/main/java/cn/hutool/setting/AbsSetting.java b/hutool-setting/src/main/java/cn/hutool/setting/AbsSetting.java
index 1023bd024..68cc57dac 100644
--- a/hutool-setting/src/main/java/cn/hutool/setting/AbsSetting.java
+++ b/hutool-setting/src/main/java/cn/hutool/setting/AbsSetting.java
@@ -10,6 +10,7 @@ import cn.hutool.core.lang.getter.GroupedTypeGetter;
 import cn.hutool.core.lang.getter.TypeGetter;
 import cn.hutool.core.reflect.ConstructorUtil;
 import cn.hutool.core.text.StrUtil;
+import cn.hutool.core.text.split.SplitUtil;
 import cn.hutool.core.util.ObjUtil;
 
 import java.io.Serializable;
@@ -125,7 +126,7 @@ public abstract class AbsSetting implements TypeGetter,
 		if (StrUtil.isBlank(value)) {
 			return null;
 		}
-		return StrUtil.splitToArray(value, delimiter);
+		return SplitUtil.splitToArray(value, delimiter);
 	}
 
 	/**
diff --git a/hutool-setting/src/main/java/cn/hutool/setting/SettingLoader.java b/hutool-setting/src/main/java/cn/hutool/setting/SettingLoader.java
index 557907d12..e8a8169e2 100755
--- a/hutool-setting/src/main/java/cn/hutool/setting/SettingLoader.java
+++ b/hutool-setting/src/main/java/cn/hutool/setting/SettingLoader.java
@@ -7,6 +7,7 @@ import cn.hutool.core.io.resource.Resource;
 import cn.hutool.core.lang.Assert;
 import cn.hutool.core.regex.ReUtil;
 import cn.hutool.core.text.StrUtil;
+import cn.hutool.core.text.split.SplitUtil;
 import cn.hutool.core.util.CharUtil;
 import cn.hutool.core.util.CharsetUtil;
 import cn.hutool.core.util.SystemUtil;
@@ -124,13 +125,14 @@ public class SettingLoader {
 					continue;
 				}
 
-				final String[] keyValue = StrUtil.splitToArray(line, this.assignFlag, 2);
+				final String[] keyValue = SplitUtil.split(line, String.valueOf(this.assignFlag), 2, true, false)
+						.toArray(new String[0]);
 				// 跳过不符合键值规范的行
 				if (keyValue.length < 2) {
 					continue;
 				}
 
-				String value = keyValue[1].trim();
+				String value = keyValue[1];
 				// 替换值中的所有变量变量（变量必须是此行之前定义的变量，否则无法找到）
 				if (this.isUseVariable) {
 					value = replaceVar(group, value);
@@ -224,7 +226,7 @@ public class SettingLoader {
 				String varValue = this.groupedMap.get(group, key);
 				// 跨分组查找
 				if (null == varValue) {
-					final List groupAndKey = StrUtil.split(key, CharUtil.DOT, 2);
+					final List groupAndKey = SplitUtil.split(key, StrUtil.DOT, 2, true, false);
 					if (groupAndKey.size() > 1) {
 						varValue = this.groupedMap.get(groupAndKey.get(0), groupAndKey.get(1));
 					}
diff --git a/hutool-swing/src/main/java/cn/hutool/swing/img/color/ColorUtil.java b/hutool-swing/src/main/java/cn/hutool/swing/img/color/ColorUtil.java
index 5a1dffab4..6dd19481c 100644
--- a/hutool-swing/src/main/java/cn/hutool/swing/img/color/ColorUtil.java
+++ b/hutool-swing/src/main/java/cn/hutool/swing/img/color/ColorUtil.java
@@ -6,6 +6,8 @@ import cn.hutool.core.lang.ansi.Ansi8BitColor;
 import cn.hutool.core.lang.ansi.AnsiElement;
 import cn.hutool.core.map.MapUtil;
 import cn.hutool.core.text.StrUtil;
+import cn.hutool.core.text.split.SplitUtil;
+import cn.hutool.core.util.ArrayUtil;
 import cn.hutool.core.util.RandomUtil;
 
 import java.awt.Color;
@@ -23,6 +25,7 @@ import java.util.Random;
 public class ColorUtil {
 
 	private static final Map COLOR_MAPPING;
+
 	static {
 		final Map colorMap = MapUtil
 				.builder("BLACK", Color.BLACK)
@@ -57,10 +60,11 @@ public class ColorUtil {
 
 	/**
 	 * 将颜色转换为CSS的rgba表示形式，输出结果格式为：rgba(red, green, blue)
+	 *
 	 * @param color AWT颜色
 	 * @return rgb(red, green, blue)
 	 */
-	public static String toCssRgb(final Color color){
+	public static String toCssRgb(final Color color) {
 		return StrUtil.builder()
 				.append("rgb(")
 				.append(color.getRed()).append(",")
@@ -71,10 +75,11 @@ public class ColorUtil {
 
 	/**
 	 * 将颜色转换为CSS的rgba表示形式，输出结果格式为：rgba(red, green, blue, alpha)
+	 *
 	 * @param color AWT颜色
 	 * @return rgba(red, green, blue, alpha)
 	 */
-	public static String toCssRgba(final Color color){
+	public static String toCssRgba(final Color color) {
 		return StrUtil.builder()
 				.append("rgba(")
 				.append(color.getRed()).append(",")
@@ -135,7 +140,7 @@ public class ColorUtil {
 
 		// 预定义颜色别名
 		final Color color = COLOR_MAPPING.get(colorName);
-		if(null != color){
+		if (null != color) {
 			return color;
 		}
 
@@ -148,19 +153,19 @@ public class ColorUtil {
 		}
 
 		// RGB值和RGBA
-		final List rgb = StrUtil.split(colorName, ',');
+		final List rgb = SplitUtil.split(colorName, StrUtil.COMMA);
 		final int size = rgb.size();
 
-		if(3 == size){
+		if (3 == size) {
 			// RGB
 			final Integer[] rgbIntegers = Convert.toIntArray(rgb);
 			return new Color(rgbIntegers[0], rgbIntegers[1], rgbIntegers[2]);
 		}
-		if(4 == size){
+		if (4 == size) {
 			// RGBA
 			final Float[] rgbFloats = Convert.toFloatArray(rgb);
 			Float a = rgbFloats[3];
-			if(a < 1){
+			if (a < 1) {
 				// 识别CSS形式
 				a *= 255;
 			}
@@ -243,7 +248,7 @@ public class ColorUtil {
 	/**
 	 * AWT的{@link Color}颜色转换为ANSI颜色，由于取最接近颜色，故可能有色差
 	 *
-	 * @param rgb        RGB颜色
+	 * @param rgb          RGB颜色
 	 * @param is8Bit       是否8bit的ANSI颜色
 	 * @param isBackground 是否背景色
 	 * @return ANSI颜色
@@ -313,7 +318,7 @@ public class ColorUtil {
 				maxCount = count;
 			}
 		}
-		final String[] splitRgbStr = StrUtil.splitToArray(maxColor, '-');
+		final String[] splitRgbStr = SplitUtil.splitToArray(maxColor, StrUtil.DASHED);
 		String rHex = Integer.toHexString(Integer.parseInt(splitRgbStr[0]));
 		String gHex = Integer.toHexString(Integer.parseInt(splitRgbStr[1]));
 		String bHex = Integer.toHexString(Integer.parseInt(splitRgbStr[2]));
@@ -333,7 +338,7 @@ public class ColorUtil {
 	 * @return 是否匹配
 	 */
 	private static boolean matchFilters(final int r, final int g, final int b, final int[]... rgbFilters) {
-		if (rgbFilters != null && rgbFilters.length > 0) {
+		if (ArrayUtil.isNotEmpty(rgbFilters)) {
 			for (final int[] rgbFilter : rgbFilters) {
 				if (r == rgbFilter[0] && g == rgbFilter[1] && b == rgbFilter[2]) {
 					return true;