fix code

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<Class<?>, Map<String, PropertyDescriptor>> pdCache = new WeakConcurrentMap<>();

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<String> parts = StrUtil.splitTrim(expression, ':');
+			final List<String> 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<String> keys = StrUtil.splitTrim(expression, ',');
+			final List<String> 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

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<String> words = StrUtil.split(morse, split);
+		final List<String> words = SplitUtil.split(morse, String.valueOf(split));
 		final StringBuilder textBuilder = new StringBuilder();
 		Integer codePoint;
 		for (String word : words) {

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 = '-';
-
+	private static final String PUNY_CODE_PREFIX = "xn--";
-	public 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<String> split = StrUtil.split(domain, CharUtil.DOT);
+		final List<String> 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<String> split = StrUtil.split(domain, CharUtil.DOT);
+		final List<String> split = SplitUtil.split(domain, StrUtil.DOT);
 		final StringBuilder result = new StringBuilder(domain.length() / 4 + 1);
 		for (final String str : split) {
 			if (result.length() != 0) {

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.*;
-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.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.*;
-import java.util.function.Function;
-import java.util.function.Predicate;
-import java.util.function.Supplier;
-import java.util.function.UnaryOperator;
 import java.util.stream.Collectors;
 
 /**
@@ -1350,7 +1324,7 @@ public class CollUtil {
 	 * @since 3.0.4
 	 */
 	public static Map<String, String> 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);
 		}

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<String>, Serializable {
 			return 1;
 		}
 
-		final List<String> v1s = StrUtil.split(version1, CharUtil.DOT);
+		final List<String> v1s = SplitUtil.splitTrim(version1, StrUtil.DOT);
-		final List<String> v2s = StrUtil.split(version2, CharUtil.DOT);
+		final List<String> v2s = SplitUtil.splitTrim(version2, StrUtil.DOT);
 
 		int diff = 0;
 		final int minLength = Math.min(v1s.size(), v2s.size());// 取最小长度值

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);
 		}
 

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
+
 	/**
 	 * 格式化日期时间<br>
 	 * 格式 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<String> hms = StrUtil.splitTrim(timeStr, CharUtil.COLON, 3);
+		final List<String> 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<String> dateAndTime = StrUtil.splitTrim(dateStr, ' ');
+		final List<String> dateAndTime = SplitUtil.splitTrim(dateStr, StrUtil.SPACE);
 		final int size = dateAndTime.size();
 		if (size < 1 || size > 2) {
 			// 非可被标准处理的格式

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<String> pathList = StrUtil.split(pathToUse, CharUtil.SLASH);
+		final List<String> pathList = SplitUtil.split(pathToUse, StrUtil.SLASH);
 
 		final List<String> pathElements = new LinkedList<>();
 		int tops = 0;

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<String> pathParts = StrUtil.split(fileName, '/', false, true);
+			final List<String> pathParts = SplitUtil.split(fileName, StrUtil.SLASH, false, true);
 			final int lastPartIndex = pathParts.size() - 1;//目录个数
 			for (int i = 0; i < lastPartIndex; i++) {
 				//由于路径拆分，slip不检查，在最后一步检查

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相关常量
  * <pre>
@@ -23,7 +25,7 @@ public interface Ipv4Pool {
     /**
      * IP与掩码的分割符
      */
-    String IP_MASK_SPLIT_MARK = "/";
+    String IP_MASK_SPLIT_MARK = StrUtil.SLASH;
 
     /**
      * localhost默认解析的ip地址

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<String> 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);

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) {
+		if (ip != null && StrUtil.indexOf(ip, CharUtil.COMMA) > 0) {
-			final List<String> ips = StrUtil.splitTrim(ip, ',');
+			final List<String> ips = SplitUtil.splitTrim(ip, StrUtil.COMMA);
 			for (final String subIp : ips) {
 				if (false == isUnknown(subIp)) {
 					ip = subIp;

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<String> split = StrUtil.split(path, '/');
+				final List<String> split = SplitUtil.split(path, StrUtil.SLASH);
 				for (final String seg : split) {
 					addInternal(URLDecoder.decodeForPath(seg, charset), false);
 				}

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<String> packages = StrUtil.split(className, CharUtil.DOT);
+		final List<String> packages = SplitUtil.split(className, StrUtil.DOT);
 		if (null == packages || packages.size() < 2) {
 			return className;
 		}

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]);
 	}
 
 	/**

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();
+		return filter(str, (c)-> false == ArrayUtil.contains(chars, c));
-		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();
 	}
 
 	/**
@@ -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));
-	}
-
-	/**
-	 * 切分字符串<br>
-	 * a#b#c =》 [a,b,c] <br>
-	 * a##b#c =》 [a,"",b,c]
-	 *
-	 * @param str       被切分的字符串
-	 * @param separator 分隔符字符
-	 * @return 切分后的集合
-	 */
-	public static List<String> 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<String> 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<String> splitTrim(final CharSequence str, final char separator) {
-		return splitTrim(str, separator, -1);
-	}
-
-	/**
-	 * 切分字符串，去除切分后每个元素两边的空白符，去除空白项
-	 *
-	 * @param str       被切分的字符串
-	 * @param separator 分隔符字符
-	 * @return 切分后的集合
-	 * @since 3.2.0
-	 */
-	public static List<String> 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<String> 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<String> 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<String> 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<String> 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 <R>         切分后元素类型
-	 * @param str         被切分的字符串
-	 * @param separator   分隔符字符
-	 * @param limit       限制分片数，-1不限制
-	 * @param ignoreEmpty 是否忽略空串
-	 * @param mapping     切分后的字符串元素的转换方法
-	 * @return 切分后的集合，元素类型是经过 mapping 转换后的
-	 * @since 5.7.14
-	 */
-	public static <R> List<R> split(final CharSequence str, final char separator, final int limit, final boolean ignoreEmpty, final Function<String, R> mapping) {
-		return SplitUtil.split(str, separator, limit, ignoreEmpty, mapping);
-	}
-
-	/**
-	 * 切分字符串，如果分隔符不存在则返回原字符串
-	 *
-	 * @param str       被切分的字符串
-	 * @param separator 分隔符
-	 * @return 字符串
-	 * @since 5.7.1
-	 */
-	public static List<String> 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<String> 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<String> 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<String> 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;
 		}
-
+		return StrRepeater.of(count).repeat(c);
-		final char[] result = new char[count];
-		for (int i = 0; i < count; i++) {
-			result[i] = c;
-		}
-		return new String(result);
 	}
 
 	/**
@@ -2131,33 +1848,15 @@ public class CharSequenceUtil extends StrChecker {
 		if (null == str) {
 			return null;
 		}
-		if (count <= 0 || str.length() == 0) {
+		return StrRepeater.of(count).repeat(str);
-			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);
 	}
 
 	/**
 	 * 重复某个字符串到指定长度
+	 * <ul>
+	 *     <li>如果指定长度非指定字符串的整数倍，截断到固定长度</li>
+	 *     <li>如果指定长度小于字符串本身的长度，截断之</li>
+	 * </ul>
 	 *
 	 * @param str    被重复的字符
 	 * @param padLen 指定长度
@@ -2171,19 +1870,7 @@ public class CharSequenceUtil extends StrChecker {
 		if (padLen <= 0) {
 			return EMPTY;
 		}
-		final int strLen = str.length();
+		return StrRepeater.of(padLen).repeatByLength(str);
-		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);
 	}
 
 	/**
@@ -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);
+		return StrRepeater.of(count).repeatAndJoin(str, delimiter);
-		builder.append(str);
-		count--;
-
-		final boolean isAppendDelimiter = isNotEmpty(delimiter);
-		while (count-- > 0) {
-			if (isAppendDelimiter) {
-				builder.append(delimiter);
-			}
-			builder.append(str);
-		}
-		return builder.toString();
 	}
 	// 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,

hutool-core/src/main/java/cn/hutool/core/text/StrEditor.java

@@ -1,5 +0,0 @@
-package cn.hutool.core.text;
-
-public class StrEditor {
-	private
-}

hutool-core/src/main/java/cn/hutool/core/text/StrRepeater.java

@@ -0,0 +1,164 @@
+package cn.hutool.core.text;
+
+/**
+ * 字符串或字符重复器<br>
+ * 用于将给定字符串或字符赋值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;
+	}
+
+	/**
+	 * 重复某个字符
+	 *
+	 * <pre>
+	 * repeat('e', 0)  = ""
+	 * repeat('e', 3)  = "eee"
+	 * repeat('e', -2) = ""
+	 * </pre>
+	 *
+	 * @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);
+	}
+
+	/**
+	 * 重复某个字符串到指定长度
+	 * <ul>
+	 *     <li>如果指定长度非指定字符串的整数倍，截断到固定长度</li>
+	 *     <li>如果指定长度小于字符串本身的长度，截断之</li>
+	 * </ul>
+	 *
+	 * @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);
+	}
+
+	/**
+	 * 重复某个字符串并通过分界符连接
+	 *
+	 * <pre>
+	 * repeatAndJoin("?", 5, ",")   = "?,?,?,?,?"
+	 * repeatAndJoin("?", 0, ",")   = ""
+	 * repeatAndJoin("?", 5, null) = "?????"
+	 * </pre>
+	 *
+	 * @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();
+	}
+}

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);
 		}
 	}
 

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.*;
-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.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
-
 	/**
-	 * 切分字符串路径，仅支持Unix分界符：/
+	 * 无限制切分个数
-	 * <p>去除每个元素两边空格，大小写敏感，忽略空串</p>
-	 *
-	 * @param str 被切分的字符串
-	 * @return 切分后的集合
-	 * @since 3.0.8
 	 */
-	public static List<String> splitPath(final CharSequence str) {
+	public static int UNLIMITED = -1;
-		return splitPath(str, 0);
+
-	}
+	// region ----- split to
 
 	/**
-	 * 切分字符串路径，仅支持Unix分界符：/
+	 * 切分字符串，去除切分后每个元素两边的空白符，去除空白项，并转为结果类型
-	 * <p>去除每个元素两边空格，大小写敏感，忽略空串</p>
 	 *
+	 * @param <T>        结果类型
 	 * @param str        被切分的字符串
-	 * @return 切分后的集合
+	 * @param separator  分隔符字符
-	 * @since 3.0.8
+	 * @param resultType 结果类型的类，可以是数组或集合
+	 * @return long数组
 	 */
-	public static String[] splitPathToArray(final CharSequence str) {
+	public static <T> T splitTo(final CharSequence str, final CharSequence separator, final Class<T> resultType) {
-		return toArray(splitPath(str));
+		return Convert.convert(resultType, splitTrim(str, separator));
 	}
+	// endregion
+
+	// region ----- Split by String or char
 
 	/**
-	 * 切分字符串路径，仅支持Unix分界符：/
+	 * 切分字符串，去除切分后每个元素两边的空白符，去除空白项
-	 * <p>去除每个元素两边空格，大小写敏感，忽略空串</p>
-	 *
-	 * @param str   被切分的字符串
-	 * @param limit 限制分片数，小于等于0表示无限制
-	 * @return 切分后的集合
-	 * @since 3.0.8
-	 */
-	public static List<String> splitPath(final CharSequence str, final int limit) {
-		return split(str, CharUtil.SLASH, limit, true, true);
-	}
-
-	/**
-	 * 切分字符串路径，仅支持Unix分界符：/
-	 * <p>去除每个元素两边空格，大小写敏感，忽略空串</p>
-	 *
-	 * @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
+	 * @since 3.2.0
 	 */
-	public static List<String> splitTrim(final CharSequence str, final char separator, final boolean ignoreEmpty) {
+	public static List<String> splitTrim(final CharSequence str, final CharSequence separator) {
-		return split(str, separator, 0, true, ignoreEmpty);
+		return split(str, separator, true, true);
 	}
 
 	/**
-	 * 切分字符串
+	 * 切分字符串，如果分隔符不存在则返回原字符串<br>
+	 * 此方法不会去除切分字符串后每个元素两边的空格，不忽略空串
 	 *
 	 * @param str       被切分的字符串
-	 * @param separator   分隔符字符
+	 * @param separator 分隔符
-	 * @param isTrim      是否去除切分字符串后每个元素两边的空格
+	 * @return 字符串
-	 * @param ignoreEmpty 是否忽略空串
-	 * @return 切分后的集合
-	 * @since 3.0.8
 	 */
-	public static List<String> split(final CharSequence str, final char separator, final boolean isTrim, final boolean ignoreEmpty) {
+	public static String[] splitToArray(final CharSequence str, final CharSequence separator) {
-		return split(str, separator, 0, isTrim, ignoreEmpty);
+		if (str == null) {
+			return new String[]{};
+		}
+		return toArray(split(str, separator));
 	}
 
 	/**
-	 * 切分字符串，大小写敏感，去除每个元素两边空白符
+	 * 切分字符串，如果分隔符不存在则返回原字符串<br>
+	 * 此方法不会去除切分字符串后每个元素两边的空格，不忽略空串
 	 *
 	 * @param str       被切分的字符串
-	 * @param separator   分隔符字符
+	 * @param separator 分隔符
-	 * @param limit       限制分片数，小于等于0表示无限制
+	 * @return 字符串
-	 * @param ignoreEmpty 是否忽略空串
-	 * @return 切分后的集合
-	 * @since 3.0.8
 	 */
-	public static List<String> splitTrim(final CharSequence str, final char separator, final int limit, final boolean ignoreEmpty) {
+	public static List<String> split(final CharSequence str, final CharSequence separator) {
-		return split(str, separator, limit, true, ignoreEmpty, false);
+		return split(str, separator, false, false);
 	}
 
-	/**
-	 * 切分字符串，大小写敏感
-	 *
-	 * @param str         被切分的字符串
-	 * @param separator   分隔符字符
-	 * @param limit       限制分片数，小于等于0表示无限制
-	 * @param isTrim      是否去除切分字符串后每个元素两边的空格
-	 * @param ignoreEmpty 是否忽略空串
-	 * @return 切分后的集合
-	 * @since 3.0.8
-	 */
-	public static List<String> 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 <R>         切分后的元素类型
-	 * @param str         被切分的字符串
-	 * @param separator   分隔符字符
-	 * @param limit       限制分片数，小于等于0表示无限制
-	 * @param ignoreEmpty 是否忽略空串
-	 * @param mapping     切分后的字符串元素的转换方法
-	 * @return 切分后的集合，元素类型是经过 mapping 转换后的
-	 * @since 5.7.14
-	 */
-	public static <R> List<R> split(final CharSequence str, final char separator, final int limit, final boolean ignoreEmpty, final Function<String, R> 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<String> 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<String> 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));
-	}
-
-	/**
-	 * 切分字符串<br>
-	 * 如果为空字符串或者null 则返回空集合
-	 *
-	 * @param <R>         切分后的元素类型
-	 * @param text        被切分的字符串
-	 * @param separator   分隔符字符
-	 * @param limit       限制分片数，小于等于0表示无限制
-	 * @param ignoreEmpty 是否忽略空串
-	 * @param ignoreCase  是否忽略大小写
-	 * @param mapping     切分后的字符串元素的转换方法
-	 * @return 切分后的集合，元素类型是经过 mapping 转换后的
-	 * @since 5.7.14
-	 */
-	public static <R> List<R> split(final CharSequence text, final char separator, final int limit, final boolean ignoreEmpty,
-									final boolean ignoreCase, final Function<String, R> mapping) {
-		if (StrUtil.isEmpty(text)) {
-			return new ArrayList<>(0);
-		}
-		final SplitIter splitIter = new SplitIter(text, new CharFinder(separator, ignoreCase), limit, ignoreEmpty);
-		return splitIter.toList(mapping);
-	}
-
-	/**
-	 * 切分字符串为字符串数组
-	 *
-	 * @param str         被切分的字符串
-	 * @param separator   分隔符字符
-	 * @param limit       限制分片数，小于等于0表示无限制
-	 * @param isTrim      是否去除切分字符串后每个元素两边的空格
-	 * @param ignoreEmpty 是否忽略空串
-	 * @return 切分后的集合
-	 * @since 3.0.8
-	 */
-	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));
-	}
-
-	//---------------------------------------------------------------------------------------------- Split by String
-
 	/**
 	 * 切分字符串，不忽略大小写
 	 *
@@ -226,21 +93,9 @@ public class SplitUtil {
 	 * @return 切分后的集合
 	 * @since 3.0.8
 	 */
-	public static List<String> split(final CharSequence str, final String separator, final boolean isTrim, final boolean ignoreEmpty) {
+	public static List<String> split(final CharSequence str, final CharSequence separator,
-		return split(str, separator, -1, isTrim, ignoreEmpty, false);
+									 final boolean isTrim, final boolean ignoreEmpty) {
-	}
+		return split(str, separator, UNLIMITED, isTrim, ignoreEmpty, false);
-
-	/**
-	 * 切分字符串，去除每个元素两边空格，不忽略大小写
-	 *
-	 * @param str         被切分的字符串
-	 * @param separator   分隔符字符串
-	 * @param ignoreEmpty 是否忽略空串
-	 * @return 切分后的集合
-	 * @since 3.2.1
-	 */
-	public static List<String> splitTrim(final CharSequence str, final String separator, final boolean ignoreEmpty) {
-		return split(str, separator, true, ignoreEmpty);
 	}
 
 	/**
@@ -254,109 +109,127 @@ public class SplitUtil {
 	 * @return 切分后的集合
 	 * @since 3.0.8
 	 */
-	public static List<String> split(final CharSequence str, final String separator, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
+	public static List<String> 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<String> 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<String> 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<String> splitTrimIgnoreCase(final CharSequence str, final String separator, final int limit, final boolean ignoreEmpty) {
-		return split(str, separator, limit, true, ignoreEmpty, true);
-	}
-
 	/**
 	 * 切分字符串<br>
 	 * 如果提供的字符串为{@code null}，则返回一个空的{@link ArrayList}<br>
 	 * 如果提供的字符串为""，则当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<String> split(final CharSequence text, final String separator, final int limit, final boolean isTrim, final boolean ignoreEmpty, final boolean ignoreCase) {
+	public static List<String> split(final CharSequence str, final CharSequence separator,
-		if(null == text){
+									 final int limit, final boolean isTrim, final boolean ignoreEmpty, final boolean ignoreCase) {
-			return new ArrayList<>(0);
+		return split(str, separator, limit, ignoreEmpty, ignoreCase, trimFunc(isTrim));
-		} 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);
 	}
 
 	/**
-	 * 切分字符串为字符串数组
+	 * 切分字符串<br>
+	 * 如果提供的字符串为{@code null}，则返回一个空的{@link ArrayList}<br>
+	 * 如果提供的字符串为""，则当ignoreEmpty时返回空的{@link ArrayList}，否则返回只有一个""元素的{@link ArrayList}
+	 *
+	 * @param <R>         元素类型
+	 * @param str         被切分的字符串
+	 * @param separator   分隔符字符串
+	 * @param limit       限制分片数，小于等于0表示无限制
+	 * @param ignoreEmpty 是否忽略空串
+	 * @param ignoreCase  是否忽略大小写
+	 * @param mapping     切分后字段映射函数
+	 * @return 切分后的集合
+	 */
+	public static <R> List<R> split(final CharSequence str, final CharSequence separator,
+									final int limit, final boolean ignoreEmpty, final boolean ignoreCase,
+									final Function<String, R> 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
+
+	/**
+	 * 切分路径字符串<br>
+	 * 如果为空字符串或者null 则返回空集合<br><br>
+	 * 空路径会被忽略
+	 *
+	 * @param str 被切分的字符串
+	 * @return 切分后的集合
+	 */
+	public static List<String> splitPath(final CharSequence str) {
+		return splitPath(str, UNLIMITED);
+	}
+
+	/**
+	 * 切分路径字符串<br>
+	 * 如果为空字符串或者null 则返回空集合<br>
+	 * 空路径会被忽略
 	 *
 	 * @param str   被切分的字符串
-	 * @param separator   分隔符字符
 	 * @param limit 限制分片数，小于等于0表示无限制
-	 * @param isTrim      是否去除切分字符串后每个元素两边的空格
-	 * @param ignoreEmpty 是否忽略空串
 	 * @return 切分后的集合
 	 * @since 3.0.8
 	 */
-	public static String[] splitToArray(final CharSequence str, final String separator, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
+	public static List<String> splitPath(final CharSequence str, final int limit) {
-		return toArray(split(str, separator, limit, isTrim, ignoreEmpty));
+		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);
+	}
 
 	/**
 	 * 使用空白符切分字符串<br>
 	 * 切分后的字符串两边不包含空白符，空串或空白符串并不做为元素之一<br>
 	 * 如果为空字符串或者null 则返回空集合
 	 *
-	 * @param text  被切分的字符串
+	 * @param str 被切分的字符串
+	 * @return 切分后的集合
+	 */
+	public static List<String> splitByBlank(final CharSequence str) {
+		return splitByBlank(str, UNLIMITED);
+	}
+
+	/**
+	 * 使用空白符切分字符串<br>
+	 * 切分后的字符串两边不包含空白符，空串或空白符串并不做为元素之一<br>
+	 * 如果为空字符串或者null 则返回空集合
+	 *
+	 * @param str   被切分的字符串
 	 * @param limit 限制分片数，小于等于0表示无限制
 	 * @return 切分后的集合
 	 * @since 3.0.8
 	 */
-	public static List<String> split(final CharSequence text, final int limit) {
+	public static List<String> splitByBlank(final CharSequence str, final int limit) {
-		if (StrUtil.isBlank(text)) {
+		if (StrUtil.isBlank(str)) {
-			return new ArrayList<>(0);
+			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) {
+	public static String[] splitByBlankToArray(final CharSequence str, final int limit) {
-		return toArray(split(str, 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<String> splitByRegex(final CharSequence text, final String separatorRegex, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
+	public static List<String> 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);
 	}
 
 	/**
 	 * 通过正则切分字符串<br>
 	 * 如果为空字符串或者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<String> split(final CharSequence text, final Pattern separatorPattern, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
+	public static List<String> splitByRegex(final CharSequence str, final Pattern separatorPattern, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
-		if (StrUtil.isEmpty(text)) {
+		if (StrUtil.isEmpty(str)) {
-			return new ArrayList<>(0);
+			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) {
+	public static String[] splitByRegexToArray(final CharSequence str, final Pattern separatorPattern, final int limit, final boolean isTrim, final boolean ignoreEmpty) {
-		return toArray(split(str, separatorPattern, limit, isTrim, ignoreEmpty));
+		return toArray(splitByRegex(str, separatorPattern, limit, isTrim, ignoreEmpty));
 	}
-	//---------------------------------------------------------------------------------------------- Split by length
 
 	/**
 	 * 根据给定长度，将给定字符串截取为多个部分
 	 *
-	 * @param text 字符串
+	 * @param str 字符串
 	 * @param len 每一个小节的长度，必须大于0
 	 * @return 截取后的字符串数组
 	 */
-	public static String[] splitByLength(final CharSequence text, final int len) {
+	public static String[] splitByLength(final CharSequence str, final int len) {
-		if (StrUtil.isEmpty(text)) {
+		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

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);
 	}
 }

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<String> 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<String> 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);
+	}
+
 }

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);
+	}
+}

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<String> 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<String> split = StrUtil.split(str, ',', -1, true, true);
-		// 测试空是否被去掉
-		Assert.assertEquals(0, split.size());
-	}
-
 	@Test
 	public void splitTest2() {
 		final String str = "a.b.";
-		final List<String> split = StrUtil.split(str, '.');
+		final List<String> 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());
+		Assert.assertEquals(0, SplitUtil.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);
 	}
 
 	@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));
 	}
 

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<String> split = SplitUtil.split(str1, ',', 0, true, true);
+		final List<String> 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<String> split = SplitUtil.split(str1, 0);
+		final List<String> 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 String str1 = "/use/local\\bin";
-		final List<String> split = SplitUtil.splitPath(str1, 0);
+		final List<String> 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<Long> split = SplitUtil.split(str, '.', 0, true, true, Long::parseLong);
+		final List<Long> 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);
 	}

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.*;
-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 java.util.ArrayList;
 import java.util.List;
@@ -103,7 +99,7 @@ public class PartParser {
 	private List<Integer> parseArray(final String value) {
 		final List<Integer> values = new ArrayList<>();
 
-		final List<String> parts = StrUtil.split(value, CharUtil.COMMA);
+		final List<String> 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<Integer> parseStep(final String value) {
-		final List<String> parts = StrUtil.split(value, CharUtil.SLASH);
+		final List<String> parts = SplitUtil.split(value, StrUtil.SLASH);
 		final int size = parts.size();
 
 		final List<Integer> results;
@@ -187,7 +183,7 @@ public class PartParser {
 		}
 
 		//Range模式
-		final List<String> parts = StrUtil.split(value, '-');
+		final List<String> parts = SplitUtil.split(value, StrUtil.DASHED);
 		final int size = parts.size();
 		if (size == 1) {// 普通值
 			final int v1 = parseNumber(value);

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<PatternMatcher> parseGroupPattern(final String groupPattern) {
-		final List<String> patternList = StrUtil.splitTrim(groupPattern, '|');
+		final List<String> patternList = SplitUtil.splitTrim(groupPattern, "|");
 		final List<PatternMatcher> patternMatchers = new ArrayList<>(patternList.size());
 		for (final String pattern : patternList) {
 			patternMatchers.add(parseSingle(pattern));

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<String> strs = StrUtil.split(valueStr, CharUtil.SPACE, 2);
+		final List<String> 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<String> betweenValueStrs = SplitUtil.splitTrimIgnoreCase(strs.get(1), LogicalOperator.AND.toString(), 2, true);
+			final List<String> 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) {
+	private static Object tryToNumber(final String value) {
-		value = StrUtil.trim(value);
 		if (false == NumberUtil.isNumber(value)) {
 			return value;
 		}

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<String> target = CollUtil.edit(StrUtil.split(field, CharUtil.DOT, 2), t -> StrUtil.format("{}{}{}", preWrapQuote, t, sufWrapQuote));
+			final Collection<String> target = CollUtil.edit(
+					// 用户名和表名不能包含空格
+					SplitUtil.split(field, StrUtil.DOT, 2, true, false),
+					// 用户名和表名都加引号
+					t -> StrUtil.format("{}{}{}", preWrapQuote, t, sufWrapQuote));
 			return CollUtil.join(target, StrUtil.DOT);
 		}
 

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

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<String> 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);
 		}

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{
 	 * </p>
 	 *
 	 * @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
-	 *
 	 * @since Java 1.3
 	 */
 	public final String getName() {
@@ -60,7 +64,6 @@ public class JavaRuntimeInfo implements Serializable{
 	 * </p>
 	 *
 	 * @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
-	 *
 	 * @since Java 1.3
 	 */
 	public final String getVersion() {
@@ -75,7 +78,6 @@ public class JavaRuntimeInfo implements Serializable{
 	 * </p>
 	 *
 	 * @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
-	 *
 	 * @since Java 1.1
 	 */
 	public final String getHomeDir() {
@@ -90,7 +92,6 @@ public class JavaRuntimeInfo implements Serializable{
 	 * </p>
 	 *
 	 * @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
-	 *
 	 * @since Java 1.3
 	 */
 	public final String getExtDirs() {
@@ -105,7 +106,6 @@ public class JavaRuntimeInfo implements Serializable{
 	 * </p>
 	 *
 	 * @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
-	 *
 	 * @since Java 1.4
 	 */
 	public final String getEndorsedDirs() {
@@ -120,7 +120,6 @@ public class JavaRuntimeInfo implements Serializable{
 	 * </p>
 	 *
 	 * @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
-	 *
 	 * @since Java 1.1
 	 */
 	public final String getClassPath() {
@@ -135,11 +134,10 @@ public class JavaRuntimeInfo implements Serializable{
 	 * </p>
 	 *
 	 * @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{
 	 * </p>
 	 *
 	 * @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
-	 *
 	 * @since Java 1.1
 	 */
 	public final String getClassVersion() {
@@ -165,7 +162,6 @@ public class JavaRuntimeInfo implements Serializable{
 	 * </p>
 	 *
 	 * @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
-	 *
 	 */
 	public final String getLibraryPath() {
 		return JAVA_LIBRARY_PATH;
@@ -179,11 +175,9 @@ public class JavaRuntimeInfo implements Serializable{
 	 * </p>
 	 *
 	 * @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{
 	 * </p>
 	 *
 	 * @return 属性值，如果不能取得（因为Java安全限制）或值不存在，则返回{@code null}。
-	 *
-	 *
 	 */
 	public final String getProtocolPackages() {
 		return SystemUtil.get("java.protocol.handler.pkgs", true);

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<String> split = StrUtil.split(getPinyin(str, splitSeparator), splitSeparator);
+		final List<String> split = SplitUtil.split(getPinyin(str, splitSeparator), splitSeparator);
 		return CollUtil.join(split, separator, (s)->String.valueOf(s.length() > 0 ? s.charAt(0) : StrUtil.EMPTY));
 	}
 }

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<SoapClient> {
 	 * @return this
 	 */
 	public SoapClient setMethod(final String methodName, final String namespaceURI) {
-		final List<String> methodNameList = StrUtil.split(methodName, ':');
+		final List<String> methodNameList = SplitUtil.split(methodName, StrUtil.COLON);
 		final QName qName;
 		if (2 == methodNameList.size()) {
 			qName = new QName(namespaceURI, methodNameList.get(1), methodNameList.get(0));

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<MutableEntry<String, Object>> 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) {

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<JWT> {
 	 * @return 三部分内容
 	 */
 	private static List<String> splitToken(final String token) {
-		final List<String> tokens = StrUtil.split(token, CharUtil.DOT);
+		final List<String> tokens = SplitUtil.split(token, StrUtil.DOT);
 		if (3 != tokens.size()) {
 			throw new JWTException("The token was expected 3 parts, but got {}.", tokens.size());
 		}

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<CharSequence>,
 		if (StrUtil.isBlank(value)) {
 			return null;
 		}
-		return StrUtil.splitToArray(value, delimiter);
+		return SplitUtil.splitToArray(value, delimiter);
 	}
 
 	/**

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<String> groupAndKey = StrUtil.split(key, CharUtil.DOT, 2);
+					final List<String> groupAndKey = SplitUtil.split(key, StrUtil.DOT, 2, true, false);
 					if (groupAndKey.size() > 1) {
 						varValue = this.groupedMap.get(groupAndKey.get(0), groupAndKey.get(1));
 					}

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<String, Color> COLOR_MAPPING;
+
 	static {
 		final Map<String, Color> 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<String> rgb = StrUtil.split(colorName, ',');
+		final List<String> 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;
 			}
@@ -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;