From bcd773b85a5962ab1e5e05e6f469daac64164e65 Mon Sep 17 00:00:00 2001
From: Looly <loolly@gmail.com>
Date: Sun, 29 Mar 2020 10:07:59 +0800
Subject: [PATCH] add method

---
 .../java/cn/hutool/core/lang/Console.java     |    9 +-
 .../java/cn/hutool/core/util/StrUtil.java     | 1025 ++++++++---------
 .../java/cn/hutool/core/util/StrUtilTest.java |    4 +-
 3 files changed, 514 insertions(+), 524 deletions(-)

diff --git a/hutool-core/src/main/java/cn/hutool/core/lang/Console.java b/hutool-core/src/main/java/cn/hutool/core/lang/Console.java
index 0f1dfd8b5..a50f4edb2 100644
--- a/hutool-core/src/main/java/cn/hutool/core/lang/Console.java
+++ b/hutool-core/src/main/java/cn/hutool/core/lang/Console.java
@@ -1,13 +1,12 @@
 package cn.hutool.core.lang;
 
-import static java.lang.System.out;
-
-import java.util.Scanner;
-
 import cn.hutool.core.util.CharUtil;
 import cn.hutool.core.util.StrUtil;
 
+import java.util.Scanner;
+
 import static java.lang.System.err;
+import static java.lang.System.out;
 
 /**
  * 命令行（控制台）工具方法类<br>
@@ -189,7 +188,7 @@ public class Console {
 	 * @since 5.2.5
 	 */
 	public static String where() {
-		StackTraceElement stackTraceElement = new Throwable().getStackTrace()[1];
+		final StackTraceElement stackTraceElement = new Throwable().getStackTrace()[1];
 		final String className = stackTraceElement.getClassName();
 		final String methodName = stackTraceElement.getMethodName();
 		final String fileName = stackTraceElement.getFileName();
diff --git a/hutool-core/src/main/java/cn/hutool/core/util/StrUtil.java b/hutool-core/src/main/java/cn/hutool/core/util/StrUtil.java
index dff3124b4..afe1ca6cf 100644
--- a/hutool-core/src/main/java/cn/hutool/core/util/StrUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/util/StrUtil.java
@@ -1,14 +1,5 @@
 package cn.hutool.core.util;
 
-import java.io.StringReader;
-import java.io.StringWriter;
-import java.nio.ByteBuffer;
-import java.nio.charset.Charset;
-import java.text.MessageFormat;
-import java.util.*;
-import java.util.Map.Entry;
-import java.util.regex.Pattern;
-
 import cn.hutool.core.comparator.VersionComparator;
 import cn.hutool.core.convert.Convert;
 import cn.hutool.core.lang.Assert;
@@ -19,11 +10,24 @@ import cn.hutool.core.text.StrFormatter;
 import cn.hutool.core.text.StrSpliter;
 import cn.hutool.core.text.TextSimilarity;
 
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.nio.ByteBuffer;
+import java.nio.charset.Charset;
+import java.text.MessageFormat;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.regex.Pattern;
+
 /**
  * 字符串工具类
- * 
- * @author xiaoleilu
  *
+ * @author xiaoleilu
  */
 public class StrUtil {
 
@@ -74,12 +78,13 @@ public class StrUtil {
 	public static final String EMPTY_JSON = "{}";
 
 	// ------------------------------------------------------------------------ Blank
+
 	/**
 	 * 字符串是否为空白 空白的定义如下： <br>
 	 * 1、为null <br>
 	 * 2、为不可见字符（如空格）<br>
 	 * 3、""<br>
-	 * 
+	 *
 	 * @param str 被检测的字符串
 	 * @return 是否为空
 	 */
@@ -105,7 +110,7 @@ public class StrUtil {
 	 * 1、为null <br>
 	 * 2、为不可见字符（如空格）<br>
 	 * 3、""<br>
-	 * 
+	 *
 	 * @param obj 对象
 	 * @return 如果为字符串是否为空串
 	 * @since 3.3.0
@@ -124,7 +129,7 @@ public class StrUtil {
 	 * 1、不为null <br>
 	 * 2、不为不可见字符（如空格）<br>
 	 * 3、不为""<br>
-	 * 
+	 *
 	 * @param str 被检测的字符串
 	 * @return 是否为非空
 	 */
@@ -134,7 +139,7 @@ public class StrUtil {
 
 	/**
 	 * 是否包含空字符串
-	 * 
+	 *
 	 * @param strs 字符串列表
 	 * @return 是否包含空字符串
 	 */
@@ -153,7 +158,7 @@ public class StrUtil {
 
 	/**
 	 * 给定所有字符串是否为空白
-	 * 
+	 *
 	 * @param strs 字符串
 	 * @return 所有字符串是否为空白
 	 */
@@ -171,11 +176,12 @@ public class StrUtil {
 	}
 
 	// ------------------------------------------------------------------------ Empty
+
 	/**
 	 * 字符串是否为空，空的定义如下:<br>
 	 * 1、为null <br>
 	 * 2、为""<br>
-	 * 
+	 *
 	 * @param str 被检测的字符串
 	 * @return 是否为空
 	 */
@@ -187,7 +193,7 @@ public class StrUtil {
 	 * 如果对象是字符串是否为空串空的定义如下:<br>
 	 * 1、为null <br>
 	 * 2、为""<br>
-	 * 
+	 *
 	 * @param obj 对象
 	 * @return 如果为字符串是否为空串
 	 * @since 3.3.0
@@ -205,21 +211,21 @@ public class StrUtil {
 	 * 字符串是否为非空白 空白的定义如下： <br>
 	 * 1、不为null <br>
 	 * 2、不为""<br>
-	 * 
+	 *
 	 * @param str 被检测的字符串
 	 * @return 是否为非空
 	 */
 	public static boolean isNotEmpty(CharSequence str) {
 		return false == isEmpty(str);
 	}
-	
+
 	/**
 	 * 当给定字符串为null时，转换为Empty
-	 * 
+	 *
 	 * @param str 被检查的字符串
 	 * @return 原字符串或者空串
-	 * @since 4.6.3
 	 * @see #nullToEmpty(CharSequence)
+	 * @since 4.6.3
 	 */
 	public static String emptyIfNull(CharSequence str) {
 		return nullToEmpty(str);
@@ -227,7 +233,7 @@ public class StrUtil {
 
 	/**
 	 * 当给定字符串为null时，转换为Empty
-	 * 
+	 *
 	 * @param str 被转换的字符串
 	 * @return 转换后的字符串
 	 */
@@ -237,17 +243,16 @@ public class StrUtil {
 
 	/**
 	 * 如果字符串是<code>null</code>，则返回指定默认字符串，否则返回字符串本身。
-	 * 
+	 *
 	 * <pre>
 	 * nullToDefault(null, &quot;default&quot;)  = &quot;default&quot;
 	 * nullToDefault(&quot;&quot;, &quot;default&quot;)    = &quot;&quot;
 	 * nullToDefault(&quot;  &quot;, &quot;default&quot;)  = &quot;  &quot;
 	 * nullToDefault(&quot;bat&quot;, &quot;default&quot;) = &quot;bat&quot;
 	 * </pre>
-	 * 
-	 * @param str 要转换的字符串
+	 *
+	 * @param str        要转换的字符串
 	 * @param defaultStr 默认字符串
-	 * 
 	 * @return 字符串本身或指定的默认字符串
 	 */
 	public static String nullToDefault(CharSequence str, String defaultStr) {
@@ -256,17 +261,16 @@ public class StrUtil {
 
 	/**
 	 * 如果字符串是<code>null</code>或者&quot;&quot;，则返回指定默认字符串，否则返回字符串本身。
-	 * 
+	 *
 	 * <pre>
 	 * emptyToDefault(null, &quot;default&quot;)  = &quot;default&quot;
 	 * emptyToDefault(&quot;&quot;, &quot;default&quot;)    = &quot;default&quot;
 	 * emptyToDefault(&quot;  &quot;, &quot;default&quot;)  = &quot;  &quot;
 	 * emptyToDefault(&quot;bat&quot;, &quot;default&quot;) = &quot;bat&quot;
 	 * </pre>
-	 * 
-	 * @param str 要转换的字符串
+	 *
+	 * @param str        要转换的字符串
 	 * @param defaultStr 默认字符串
-	 * 
 	 * @return 字符串本身或指定的默认字符串
 	 * @since 4.1.0
 	 */
@@ -276,17 +280,16 @@ public class StrUtil {
 
 	/**
 	 * 如果字符串是<code>null</code>或者&quot;&quot;或者空白，则返回指定默认字符串，否则返回字符串本身。
-	 * 
+	 *
 	 * <pre>
 	 * emptyToDefault(null, &quot;default&quot;)  = &quot;default&quot;
 	 * emptyToDefault(&quot;&quot;, &quot;default&quot;)    = &quot;default&quot;
 	 * emptyToDefault(&quot;  &quot;, &quot;default&quot;)  = &quot;default&quot;
 	 * emptyToDefault(&quot;bat&quot;, &quot;default&quot;) = &quot;bat&quot;
 	 * </pre>
-	 * 
-	 * @param str 要转换的字符串
+	 *
+	 * @param str        要转换的字符串
 	 * @param defaultStr 默认字符串
-	 * 
 	 * @return 字符串本身或指定的默认字符串
 	 * @since 4.1.0
 	 */
@@ -296,7 +299,7 @@ public class StrUtil {
 
 	/**
 	 * 当给定字符串为空字符串时，转换为<code>null</code>
-	 * 
+	 *
 	 * @param str 被转换的字符串
 	 * @return 转换后的字符串
 	 */
@@ -306,7 +309,7 @@ public class StrUtil {
 
 	/**
 	 * 是否包含空字符串
-	 * 
+	 *
 	 * @param strs 字符串列表
 	 * @return 是否包含空字符串
 	 */
@@ -325,7 +328,7 @@ public class StrUtil {
 
 	/**
 	 * 是否全部为空字符串
-	 * 
+	 *
 	 * @param strs 字符串列表
 	 * @return 是否全部为空字符串
 	 */
@@ -344,7 +347,7 @@ public class StrUtil {
 
 	/**
 	 * 检查字符串是否为null、“null”、“undefined”
-	 * 
+	 *
 	 * @param str 被检查的字符串
 	 * @return 是否为null、“null”、“undefined”
 	 * @since 4.0.10
@@ -358,7 +361,7 @@ public class StrUtil {
 
 	/**
 	 * 检查字符串是否为null、“”、“null”、“undefined”
-	 * 
+	 *
 	 * @param str 被检查的字符串
 	 * @return 是否为null、“”、“null”、“undefined”
 	 * @since 4.0.10
@@ -372,7 +375,7 @@ public class StrUtil {
 
 	/**
 	 * 检查字符串是否为null、空白串、“null”、“undefined”
-	 * 
+	 *
 	 * @param str 被检查的字符串
 	 * @return 是否为null、空白串、“null”、“undefined”
 	 * @since 4.0.10
@@ -386,7 +389,7 @@ public class StrUtil {
 
 	/**
 	 * 是否为“null”、“undefined”，不做空指针检查
-	 * 
+	 *
 	 * @param str 字符串
 	 * @return 是否为“null”、“undefined”
 	 */
@@ -396,12 +399,13 @@ public class StrUtil {
 	}
 
 	// ------------------------------------------------------------------------ Trim
+
 	/**
 	 * 除去字符串头尾部的空白，如果字符串是<code>null</code>，依然返回<code>null</code>。
-	 * 
+	 *
 	 * <p>
 	 * 注意，和<code>String.trim</code>不同，此方法使用<code>NumberUtil.isBlankChar</code> 来判定空白， 因而可以除去英文字符集之外的其它空白，如中文空格。
-	 * 
+	 *
 	 * <pre>
 	 * trim(null)          = null
 	 * trim(&quot;&quot;)            = &quot;&quot;
@@ -409,9 +413,8 @@ public class StrUtil {
 	 * trim(&quot;abc&quot;)         = &quot;abc&quot;
 	 * trim(&quot;    abc    &quot;) = &quot;abc&quot;
 	 * </pre>
-	 * 
+	 *
 	 * @param str 要处理的字符串
-	 * 
 	 * @return 除去头尾空白的字符串，如果原字串为<code>null</code>，则返回<code>null</code>
 	 */
 	public static String trim(CharSequence str) {
@@ -420,7 +423,7 @@ public class StrUtil {
 
 	/**
 	 * 给定字符串数组全部做去首尾空格
-	 * 
+	 *
 	 * @param strs 字符串数组
 	 */
 	public static void trim(String[] strs) {
@@ -477,10 +480,10 @@ public class StrUtil {
 
 	/**
 	 * 除去字符串头部的空白，如果字符串是<code>null</code>，则返回<code>null</code>。
-	 * 
+	 *
 	 * <p>
 	 * 注意，和<code>String.trim</code>不同，此方法使用<code>CharUtil.isBlankChar</code> 来判定空白， 因而可以除去英文字符集之外的其它空白，如中文空格。
-	 * 
+	 *
 	 * <pre>
 	 * trimStart(null)         = null
 	 * trimStart(&quot;&quot;)           = &quot;&quot;
@@ -489,9 +492,8 @@ public class StrUtil {
 	 * trimStart(&quot;abc  &quot;)      = &quot;abc  &quot;
 	 * trimStart(&quot; abc &quot;)      = &quot;abc &quot;
 	 * </pre>
-	 * 
+	 *
 	 * @param str 要处理的字符串
-	 * 
 	 * @return 除去空白的字符串，如果原字串为<code>null</code>或结果字符串为<code>""</code>，则返回 <code>null</code>
 	 */
 	public static String trimStart(CharSequence str) {
@@ -500,10 +502,10 @@ public class StrUtil {
 
 	/**
 	 * 除去字符串尾部的空白，如果字符串是<code>null</code>，则返回<code>null</code>。
-	 * 
+	 *
 	 * <p>
 	 * 注意，和<code>String.trim</code>不同，此方法使用<code>CharUtil.isBlankChar</code> 来判定空白， 因而可以除去英文字符集之外的其它空白，如中文空格。
-	 * 
+	 *
 	 * <pre>
 	 * trimEnd(null)       = null
 	 * trimEnd(&quot;&quot;)         = &quot;&quot;
@@ -512,9 +514,8 @@ public class StrUtil {
 	 * trimEnd(&quot;abc  &quot;)    = &quot;abc&quot;
 	 * trimEnd(&quot; abc &quot;)    = &quot; abc&quot;
 	 * </pre>
-	 * 
+	 *
 	 * @param str 要处理的字符串
-	 * 
 	 * @return 除去空白的字符串，如果原字串为<code>null</code>或结果字符串为<code>""</code>，则返回 <code>null</code>
 	 */
 	public static String trimEnd(CharSequence str) {
@@ -523,10 +524,9 @@ public class StrUtil {
 
 	/**
 	 * 除去字符串头尾部的空白符，如果字符串是<code>null</code>，依然返回<code>null</code>。
-	 * 
-	 * @param str 要处理的字符串
+	 *
+	 * @param str  要处理的字符串
 	 * @param mode <code>-1</code>表示trimStart，<code>0</code>表示trim全部， <code>1</code>表示trimEnd
-	 * 
 	 * @return 除去指定字符后的的字符串，如果原字串为<code>null</code>，则返回<code>null</code>
 	 */
 	public static String trim(CharSequence str, int mode) {
@@ -561,9 +561,9 @@ public class StrUtil {
 
 	/**
 	 * 字符串是否以给定字符开始
-	 * 
+	 *
 	 * @param str 字符串
-	 * @param c 字符
+	 * @param c   字符
 	 * @return 是否开始
 	 */
 	public static boolean startWith(CharSequence str, char c) {
@@ -573,9 +573,9 @@ public class StrUtil {
 	/**
 	 * 是否以指定字符串开头<br>
 	 * 如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false
-	 * 
-	 * @param str 被监测字符串
-	 * @param prefix 开头字符串
+	 *
+	 * @param str          被监测字符串
+	 * @param prefix       开头字符串
 	 * @param isIgnoreCase 是否忽略大小写
 	 * @return 是否以指定字符串开头
 	 */
@@ -593,8 +593,8 @@ public class StrUtil {
 
 	/**
 	 * 是否以指定字符串开头
-	 * 
-	 * @param str 被监测字符串
+	 *
+	 * @param str    被监测字符串
 	 * @param prefix 开头字符串
 	 * @return 是否以指定字符串开头
 	 */
@@ -604,8 +604,8 @@ public class StrUtil {
 
 	/**
 	 * 是否以指定字符串开头，忽略大小写
-	 * 
-	 * @param str 被监测字符串
+	 *
+	 * @param str    被监测字符串
 	 * @param prefix 开头字符串
 	 * @return 是否以指定字符串开头
 	 */
@@ -616,8 +616,8 @@ public class StrUtil {
 	/**
 	 * 给定字符串是否以任何一个字符串开始<br>
 	 * 给定字符串和数组为空都返回false
-	 * 
-	 * @param str 给定字符串
+	 *
+	 * @param str      给定字符串
 	 * @param prefixes 需要检测的开始字符串
 	 * @return 给定字符串是否以任何一个字符串开始
 	 * @since 3.0.6
@@ -637,9 +637,9 @@ public class StrUtil {
 
 	/**
 	 * 字符串是否以给定字符结尾
-	 * 
+	 *
 	 * @param str 字符串
-	 * @param c 字符
+	 * @param c   字符
 	 * @return 是否结尾
 	 */
 	public static boolean endWith(CharSequence str, char c) {
@@ -649,9 +649,9 @@ public class StrUtil {
 	/**
 	 * 是否以指定字符串结尾<br>
 	 * 如果给定的字符串和开头字符串都为null则返回true，否则任意一个值为null返回false
-	 * 
-	 * @param str 被监测字符串
-	 * @param suffix 结尾字符串
+	 *
+	 * @param str          被监测字符串
+	 * @param suffix       结尾字符串
 	 * @param isIgnoreCase 是否忽略大小写
 	 * @return 是否以指定字符串结尾
 	 */
@@ -669,8 +669,8 @@ public class StrUtil {
 
 	/**
 	 * 是否以指定字符串结尾
-	 * 
-	 * @param str 被监测字符串
+	 *
+	 * @param str    被监测字符串
 	 * @param suffix 结尾字符串
 	 * @return 是否以指定字符串结尾
 	 */
@@ -680,8 +680,8 @@ public class StrUtil {
 
 	/**
 	 * 是否以指定字符串结尾，忽略大小写
-	 * 
-	 * @param str 被监测字符串
+	 *
+	 * @param str    被监测字符串
 	 * @param suffix 结尾字符串
 	 * @return 是否以指定字符串结尾
 	 */
@@ -692,8 +692,8 @@ public class StrUtil {
 	/**
 	 * 给定字符串是否以任何一个字符串结尾<br>
 	 * 给定字符串和数组为空都返回false
-	 * 
-	 * @param str 给定字符串
+	 *
+	 * @param str      给定字符串
 	 * @param suffixes 需要检测的结尾字符串
 	 * @return 给定字符串是否以任何一个字符串结尾
 	 * @since 3.0.6
@@ -713,8 +713,8 @@ public class StrUtil {
 
 	/**
 	 * 指定字符是否在字符串中出现过
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str        字符串
 	 * @param searchChar 被查找的字符
 	 * @return 是否包含
 	 * @since 3.1.2
@@ -726,13 +726,13 @@ public class StrUtil {
 	/**
 	 * 指定字符串是否在字符串中出现过
 	 *
-	 * @param str 字符串
+	 * @param str       字符串
 	 * @param searchStr 被查找的字符串
 	 * @return 是否包含
 	 * @since 5.1.1
 	 */
 	public static boolean contains(CharSequence str, CharSequence searchStr) {
-		if(null == str || null == searchStr){
+		if (null == str || null == searchStr) {
 			return false;
 		}
 		return str.toString().contains(searchStr);
@@ -740,8 +740,8 @@ public class StrUtil {
 
 	/**
 	 * 查找指定字符串是否包含指定字符串列表中的任意一个字符串
-	 * 
-	 * @param str 指定字符串
+	 *
+	 * @param str      指定字符串
 	 * @param testStrs 需要检查的字符串数组
 	 * @return 是否包含任意一个字符串
 	 * @since 3.2.0
@@ -752,8 +752,8 @@ public class StrUtil {
 
 	/**
 	 * 查找指定字符串是否包含指定字符列表中的任意一个字符
-	 * 
-	 * @param str 指定字符串
+	 *
+	 * @param str       指定字符串
 	 * @param testChars 需要检查的字符数组
 	 * @return 是否包含任意一个字符
 	 * @since 4.1.11
@@ -772,8 +772,8 @@ public class StrUtil {
 
 	/**
 	 * 检查指定字符串中是否只包含给定的字符
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str       字符串
 	 * @param testChars 检查的字符
 	 * @return 字符串含有非检查的字符，返回false
 	 * @since 4.4.1
@@ -793,7 +793,7 @@ public class StrUtil {
 	/**
 	 * 给定字符串是否包含空白符（空白符包括空格、制表符、全角空格和不间断空格）<br>
 	 * 如果给定字符串为null或者""，则返回false
-	 * 
+	 *
 	 * @param str 字符串
 	 * @return 是否包含空白符
 	 * @since 4.0.8
@@ -817,8 +817,8 @@ public class StrUtil {
 
 	/**
 	 * 查找指定字符串是否包含指定字符串列表中的任意一个字符串，如果包含返回找到的第一个字符串
-	 * 
-	 * @param str 指定字符串
+	 *
+	 * @param str      指定字符串
 	 * @param testStrs 需要检查的字符串数组
 	 * @return 被包含的第一个字符串
 	 * @since 3.2.0
@@ -837,8 +837,8 @@ public class StrUtil {
 
 	/**
 	 * 是否包含特定字符，忽略大小写，如果给定两个参数都为<code>null</code>，返回true
-	 * 
-	 * @param str 被检测字符串
+	 *
+	 * @param str     被检测字符串
 	 * @param testStr 被测试是否包含的字符串
 	 * @return 是否包含
 	 */
@@ -853,8 +853,8 @@ public class StrUtil {
 	/**
 	 * 查找指定字符串是否包含指定字符串列表中的任意一个字符串<br>
 	 * 忽略大小写
-	 * 
-	 * @param str 指定字符串
+	 *
+	 * @param str      指定字符串
 	 * @param testStrs 需要检查的字符串数组
 	 * @return 是否包含任意一个字符串
 	 * @since 3.2.0
@@ -866,8 +866,8 @@ public class StrUtil {
 	/**
 	 * 查找指定字符串是否包含指定字符串列表中的任意一个字符串，如果包含返回找到的第一个字符串<br>
 	 * 忽略大小写
-	 * 
-	 * @param str 指定字符串
+	 *
+	 * @param str      指定字符串
 	 * @param testStrs 需要检查的字符串数组
 	 * @return 被包含的第一个字符串
 	 * @since 3.2.0
@@ -887,13 +887,13 @@ public class StrUtil {
 	/**
 	 * 获得set或get或is方法对应的标准属性名<br>
 	 * 例如：setName 返回 name
-	 * 
+	 *
 	 * <pre>
 	 * getName =》name
 	 * setName =》name
 	 * isName  =》name
 	 * </pre>
-	 * 
+	 *
 	 * @param getOrSetMethodName Get或Set方法名
 	 * @return 如果是set或get方法名，返回field， 否则null
 	 */
@@ -901,7 +901,7 @@ public class StrUtil {
 		final String getOrSetMethodNameStr = getOrSetMethodName.toString();
 		if (getOrSetMethodNameStr.startsWith("get") || getOrSetMethodNameStr.startsWith("set")) {
 			return removePreAndLowerFirst(getOrSetMethodName, 3);
-		} else if(getOrSetMethodNameStr.startsWith("is")) {
+		} else if (getOrSetMethodNameStr.startsWith("is")) {
 			return removePreAndLowerFirst(getOrSetMethodName, 2);
 		}
 		return null;
@@ -910,7 +910,7 @@ public class StrUtil {
 	/**
 	 * 生成set方法名<br>
 	 * 例如：name 返回 setName
-	 * 
+	 *
 	 * @param fieldName 属性名
 	 * @return setXxx
 	 */
@@ -920,7 +920,7 @@ public class StrUtil {
 
 	/**
 	 * 生成get方法名
-	 * 
+	 *
 	 * @param fieldName 属性名
 	 * @return getXxx
 	 */
@@ -931,8 +931,8 @@ public class StrUtil {
 	/**
 	 * 移除字符串中所有给定字符串<br>
 	 * 例：removeAll("aa-bb-cc-dd", "-") =》 aabbccdd
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str         字符串
 	 * @param strToRemove 被移除的字符串
 	 * @return 移除后的字符串
 	 */
@@ -945,8 +945,8 @@ public class StrUtil {
 
 	/**
 	 * 去除字符串中指定的多个字符，如有多个则全部去除
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str   字符串
 	 * @param chars 字符列表
 	 * @return 去除后的字符
 	 * @since 4.2.2
@@ -972,12 +972,12 @@ public class StrUtil {
 
 	/**
 	 * 去除所有换行符，包括：
-	 * 
+	 *
 	 * <pre>
 	 * 1. \r
 	 * 1. \n
 	 * </pre>
-	 * 
+	 *
 	 * @param str 字符串
 	 * @return 处理后的字符串
 	 * @since 4.2.2
@@ -989,8 +989,8 @@ public class StrUtil {
 	/**
 	 * 去掉首部指定长度的字符串并将剩余字符串首字母小写<br>
 	 * 例如：str=setName, preLength=3 =》 return name
-	 * 
-	 * @param str 被处理的字符串
+	 *
+	 * @param str       被处理的字符串
 	 * @param preLength 去掉的长度
 	 * @return 处理后的字符串，不符合规范返回null
 	 */
@@ -1012,8 +1012,8 @@ public class StrUtil {
 	/**
 	 * 去掉首部指定长度的字符串并将剩余字符串首字母小写<br>
 	 * 例如：str=setName, prefix=set =》 return name
-	 * 
-	 * @param str 被处理的字符串
+	 *
+	 * @param str    被处理的字符串
 	 * @param prefix 前缀
 	 * @return 处理后的字符串，不符合规范返回null
 	 */
@@ -1023,8 +1023,8 @@ public class StrUtil {
 
 	/**
 	 * 原字符串首字母大写并在其首部添加指定字符串 例如：str=name, preString=get =》 return getName
-	 * 
-	 * @param str 被处理的字符串
+	 *
+	 * @param str       被处理的字符串
 	 * @param preString 添加的首部
 	 * @return 处理后的字符串
 	 */
@@ -1038,7 +1038,7 @@ public class StrUtil {
 	/**
 	 * 大写首字母<br>
 	 * 例如：str = name, return Name
-	 * 
+	 *
 	 * @param str 字符串
 	 * @return 字符串
 	 */
@@ -1058,7 +1058,7 @@ public class StrUtil {
 	/**
 	 * 小写首字母<br>
 	 * 例如：str = Name, return name
-	 * 
+	 *
 	 * @param str 字符串
 	 * @return 字符串
 	 */
@@ -1077,8 +1077,8 @@ public class StrUtil {
 
 	/**
 	 * 去掉指定前缀
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str    字符串
 	 * @param prefix 前缀
 	 * @return 切掉后的字符串，若前缀不是 preffix， 返回原字符串
 	 */
@@ -1096,8 +1096,8 @@ public class StrUtil {
 
 	/**
 	 * 忽略大小写去掉指定前缀
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str    字符串
 	 * @param prefix 前缀
 	 * @return 切掉后的字符串，若前缀不是 prefix， 返回原字符串
 	 */
@@ -1115,8 +1115,8 @@ public class StrUtil {
 
 	/**
 	 * 去掉指定后缀
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str    字符串
 	 * @param suffix 后缀
 	 * @return 切掉后的字符串，若后缀不是 suffix， 返回原字符串
 	 */
@@ -1134,8 +1134,8 @@ public class StrUtil {
 
 	/**
 	 * 去掉指定后缀，并小写首字母
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str    字符串
 	 * @param suffix 后缀
 	 * @return 切掉后的字符串，若后缀不是 suffix， 返回原字符串
 	 */
@@ -1145,8 +1145,8 @@ public class StrUtil {
 
 	/**
 	 * 忽略大小写去掉指定后缀
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str    字符串
 	 * @param suffix 后缀
 	 * @return 切掉后的字符串，若后缀不是 suffix， 返回原字符串
 	 */
@@ -1164,8 +1164,8 @@ public class StrUtil {
 
 	/**
 	 * 去除两边的指定字符串
-	 * 
-	 * @param str 被处理的字符串
+	 *
+	 * @param str            被处理的字符串
 	 * @param prefixOrSuffix 前缀或后缀
 	 * @return 处理后的字符串
 	 * @since 3.1.2
@@ -1180,8 +1180,8 @@ public class StrUtil {
 
 	/**
 	 * 去除两边的指定字符串
-	 * 
-	 * @param str 被处理的字符串
+	 *
+	 * @param str    被处理的字符串
 	 * @param prefix 前缀
 	 * @param suffix 后缀
 	 * @return 处理后的字符串
@@ -1208,8 +1208,8 @@ public class StrUtil {
 
 	/**
 	 * 去除两边的指定字符串，忽略大小写
-	 * 
-	 * @param str 被处理的字符串
+	 *
+	 * @param str            被处理的字符串
 	 * @param prefixOrSuffix 前缀或后缀
 	 * @return 处理后的字符串
 	 * @since 3.1.2
@@ -1220,8 +1220,8 @@ public class StrUtil {
 
 	/**
 	 * 去除两边的指定字符串，忽略大小写
-	 * 
-	 * @param str 被处理的字符串
+	 *
+	 * @param str    被处理的字符串
 	 * @param prefix 前缀
 	 * @param suffix 后缀
 	 * @return 处理后的字符串
@@ -1246,8 +1246,8 @@ public class StrUtil {
 
 	/**
 	 * 如果给定字符串不是以prefix开头的，在开头补充 prefix
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str    字符串
 	 * @param prefix 前缀
 	 * @return 补充后的字符串
 	 */
@@ -1266,8 +1266,8 @@ public class StrUtil {
 
 	/**
 	 * 如果给定字符串不是以suffix结尾的，在尾部补充 suffix
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str    字符串
 	 * @param suffix 后缀
 	 * @return 补充后的字符串
 	 */
@@ -1286,7 +1286,7 @@ public class StrUtil {
 
 	/**
 	 * 清理空白字符
-	 * 
+	 *
 	 * @param str 被清理的字符串
 	 * @return 清理后的字符串
 	 */
@@ -1308,10 +1308,11 @@ public class StrUtil {
 	}
 
 	// ------------------------------------------------------------------------------ Split
+
 	/**
 	 * 切分字符串
-	 * 
-	 * @param str 被切分的字符串
+	 *
+	 * @param str       被切分的字符串
 	 * @param separator 分隔符字符
 	 * @return 切分后的数组
 	 */
@@ -1321,8 +1322,8 @@ public class StrUtil {
 
 	/**
 	 * 切分字符串为long数组
-	 * 
-	 * @param str 被切分的字符串
+	 *
+	 * @param str       被切分的字符串
 	 * @param separator 分隔符
 	 * @return 切分后long数组
 	 * @since 4.0.6
@@ -1333,8 +1334,8 @@ public class StrUtil {
 
 	/**
 	 * 切分字符串为long数组
-	 * 
-	 * @param str 被切分的字符串
+	 *
+	 * @param str       被切分的字符串
 	 * @param separator 分隔符字符串
 	 * @return 切分后long数组
 	 * @since 4.0.6
@@ -1345,8 +1346,8 @@ public class StrUtil {
 
 	/**
 	 * 切分字符串为int数组
-	 * 
-	 * @param str 被切分的字符串
+	 *
+	 * @param str       被切分的字符串
 	 * @param separator 分隔符
 	 * @return 切分后long数组
 	 * @since 4.0.6
@@ -1357,8 +1358,8 @@ public class StrUtil {
 
 	/**
 	 * 切分字符串为int数组
-	 * 
-	 * @param str 被切分的字符串
+	 *
+	 * @param str       被切分的字符串
 	 * @param separator 分隔符字符串
 	 * @return 切分后long数组
 	 * @since 4.0.6
@@ -1371,8 +1372,8 @@ public class StrUtil {
 	 * 切分字符串<br>
 	 * a#b#c =》 [a,b,c] <br>
 	 * a##b#c =》 [a,"",b,c]
-	 * 
-	 * @param str 被切分的字符串
+	 *
+	 * @param str       被切分的字符串
 	 * @param separator 分隔符字符
 	 * @return 切分后的集合
 	 */
@@ -1382,25 +1383,25 @@ public class StrUtil {
 
 	/**
 	 * 切分字符串
-	 * 
-	 * @param str 被切分的字符串
+	 *
+	 * @param str       被切分的字符串
 	 * @param separator 分隔符字符
-	 * @param limit 限制分片数
+	 * @param limit     限制分片数
 	 * @return 切分后的数组
 	 */
 	public static String[] splitToArray(CharSequence str, char separator, int limit) {
 		if (null == str) {
-			return new String[] {};
+			return new String[]{};
 		}
 		return StrSpliter.splitToArray(str.toString(), separator, limit, false, false);
 	}
 
 	/**
 	 * 切分字符串，不去除切分后每个元素两边的空白符，不去除空白项
-	 * 
-	 * @param str 被切分的字符串
+	 *
+	 * @param str       被切分的字符串
 	 * @param separator 分隔符字符
-	 * @param limit 限制分片数，-1不限制
+	 * @param limit     限制分片数，-1不限制
 	 * @return 切分后的集合
 	 */
 	public static List<String> split(CharSequence str, char separator, int limit) {
@@ -1409,8 +1410,8 @@ public class StrUtil {
 
 	/**
 	 * 切分字符串，去除切分后每个元素两边的空白符，去除空白项
-	 * 
-	 * @param str 被切分的字符串
+	 *
+	 * @param str       被切分的字符串
 	 * @param separator 分隔符字符
 	 * @return 切分后的集合
 	 * @since 3.1.2
@@ -1421,8 +1422,8 @@ public class StrUtil {
 
 	/**
 	 * 切分字符串，去除切分后每个元素两边的空白符，去除空白项
-	 * 
-	 * @param str 被切分的字符串
+	 *
+	 * @param str       被切分的字符串
 	 * @param separator 分隔符字符
 	 * @return 切分后的集合
 	 * @since 3.2.0
@@ -1433,10 +1434,10 @@ public class StrUtil {
 
 	/**
 	 * 切分字符串，去除切分后每个元素两边的空白符，去除空白项
-	 * 
-	 * @param str 被切分的字符串
+	 *
+	 * @param str       被切分的字符串
 	 * @param separator 分隔符字符
-	 * @param limit 限制分片数，-1不限制
+	 * @param limit     限制分片数，-1不限制
 	 * @return 切分后的集合
 	 * @since 3.1.0
 	 */
@@ -1446,10 +1447,10 @@ public class StrUtil {
 
 	/**
 	 * 切分字符串，去除切分后每个元素两边的空白符，去除空白项
-	 * 
-	 * @param str 被切分的字符串
+	 *
+	 * @param str       被切分的字符串
 	 * @param separator 分隔符字符
-	 * @param limit 限制分片数，-1不限制
+	 * @param limit     限制分片数，-1不限制
 	 * @return 切分后的集合
 	 * @since 3.2.0
 	 */
@@ -1459,10 +1460,10 @@ public class StrUtil {
 
 	/**
 	 * 切分字符串，不限制分片数量
-	 * 
-	 * @param str 被切分的字符串
-	 * @param separator 分隔符字符
-	 * @param isTrim 是否去除切分字符串后每个元素两边的空格
+	 *
+	 * @param str         被切分的字符串
+	 * @param separator   分隔符字符
+	 * @param isTrim      是否去除切分字符串后每个元素两边的空格
 	 * @param ignoreEmpty 是否忽略空串
 	 * @return 切分后的集合
 	 * @since 3.0.8
@@ -1473,11 +1474,11 @@ public class StrUtil {
 
 	/**
 	 * 切分字符串
-	 * 
-	 * @param str 被切分的字符串
-	 * @param separator 分隔符字符
-	 * @param limit 限制分片数，-1不限制
-	 * @param isTrim 是否去除切分字符串后每个元素两边的空格
+	 *
+	 * @param str         被切分的字符串
+	 * @param separator   分隔符字符
+	 * @param limit       限制分片数，-1不限制
+	 * @param isTrim      是否去除切分字符串后每个元素两边的空格
 	 * @param ignoreEmpty 是否忽略空串
 	 * @return 切分后的集合
 	 * @since 3.0.8
@@ -1491,11 +1492,11 @@ public class StrUtil {
 
 	/**
 	 * 切分字符串
-	 * 
-	 * @param str 被切分的字符串
-	 * @param separator 分隔符字符
-	 * @param limit 限制分片数，-1不限制
-	 * @param isTrim 是否去除切分字符串后每个元素两边的空格
+	 *
+	 * @param str         被切分的字符串
+	 * @param separator   分隔符字符
+	 * @param limit       限制分片数，-1不限制
+	 * @param isTrim      是否去除切分字符串后每个元素两边的空格
 	 * @param ignoreEmpty 是否忽略空串
 	 * @return 切分后的集合
 	 * @since 3.2.0
@@ -1510,14 +1511,14 @@ public class StrUtil {
 
 	/**
 	 * 切分字符串
-	 * 
-	 * @param str 被切分的字符串
+	 *
+	 * @param str       被切分的字符串
 	 * @param separator 分隔符
 	 * @return 字符串
 	 */
 	public static String[] split(CharSequence str, CharSequence separator) {
 		if (str == null) {
-			return new String[] {};
+			return new String[]{};
 		}
 
 		final String separatorStr = (null == separator) ? null : separator.toString();
@@ -1526,7 +1527,7 @@ public class StrUtil {
 
 	/**
 	 * 根据给定长度，将给定字符串截取为多个部分
-	 * 
+	 *
 	 * @param str 字符串
 	 * @param len 每一个小节的长度
 	 * @return 截取后的字符串数组
@@ -1534,7 +1535,7 @@ public class StrUtil {
 	 */
 	public static String[] split(CharSequence str, int len) {
 		if (null == str) {
-			return new String[] {};
+			return new String[]{};
 		}
 		return StrSpliter.splitByLength(str.toString(), len);
 	}
@@ -1547,10 +1548,10 @@ public class StrUtil {
 	 * 如果经过修正的index中from大于to，则互换from和to example: <br>
 	 * abcdefgh 2 3 =》 c <br>
 	 * abcdefgh 2 -3 =》 cde <br>
-	 * 
-	 * @param str String
+	 *
+	 * @param str       String
 	 * @param fromIndex 开始的index（包括）
-	 * @param toIndex 结束的index（不包括）
+	 * @param toIndex   结束的index（不包括）
 	 * @return 字串
 	 */
 	public static String sub(CharSequence str, int fromIndex, int toIndex) {
@@ -1593,9 +1594,9 @@ public class StrUtil {
 	/**
 	 * 通过CodePoint截取字符串，可以截断Emoji
 	 *
-	 * @param str String
+	 * @param str       String
 	 * @param fromIndex 开始的index（包括）
-	 * @param toIndex 结束的index（不包括）
+	 * @param toIndex   结束的index（不包括）
 	 * @return 字串
 	 */
 	public static String subByCodePoint(CharSequence str, int fromIndex, int toIndex) {
@@ -1620,8 +1621,8 @@ public class StrUtil {
 	/**
 	 * 截取部分字符串，这里一个汉字的长度认为是2
 	 *
-	 * @param str 字符串
-	 * @param len 切割的位置
+	 * @param str    字符串
+	 * @param len    切割的位置
 	 * @param suffix 切割后加上后缀
 	 * @return 切割后的字符串
 	 * @since 3.1.1
@@ -1651,7 +1652,7 @@ public class StrUtil {
 
 	/**
 	 * 限制字符串长度，如果超过指定长度，截取指定长度并在末尾加"..."
-	 * 
+	 *
 	 * @param string 字符串
 	 * @param length 最大长度
 	 * @return 切割后的剩余的前半部分字符串+"..."
@@ -1670,8 +1671,8 @@ public class StrUtil {
 
 	/**
 	 * 切割指定位置之前部分的字符串
-	 * 
-	 * @param string 字符串
+	 *
+	 * @param string  字符串
 	 * @param toIndex 切割到的位置（不包括）
 	 * @return 切割后的剩余的前半部分字符串
 	 */
@@ -1681,8 +1682,8 @@ public class StrUtil {
 
 	/**
 	 * 切割指定位置之后部分的字符串
-	 * 
-	 * @param string 字符串
+	 *
+	 * @param string    字符串
 	 * @param fromIndex 切割开始的位置（包括）
 	 * @return 切割后后剩余的后半部分字符串
 	 */
@@ -1695,7 +1696,7 @@ public class StrUtil {
 
 	/**
 	 * 切割指定长度的后部分的字符串
-	 * 
+	 *
 	 * <pre>
 	 * StrUtil.subSufByLength("abcde", 3)      =    "cde"
 	 * StrUtil.subSufByLength("abcde", 0)      =    ""
@@ -1705,7 +1706,7 @@ public class StrUtil {
 	 * StrUtil.subSufByLength("abcde", 10)     =    "abcde"
 	 * StrUtil.subSufByLength(null, 3)               =    null
 	 * </pre>
-	 * 
+	 *
 	 * @param string 字符串
 	 * @param length 切割长度
 	 * @return 切割后后剩余的后半部分字符串
@@ -1724,10 +1725,10 @@ public class StrUtil {
 	/**
 	 * 截取字符串,从指定位置开始,截取指定长度的字符串<br>
 	 * author weibaohui
-	 * 
-	 * @param input 原始字符串
+	 *
+	 * @param input     原始字符串
 	 * @param fromIndex 开始的index,包括
-	 * @param length 要截取的长度
+	 * @param length    要截取的长度
 	 * @return 截取后的字符串
 	 */
 	public static String subWithLength(String input, int fromIndex, int length) {
@@ -1738,7 +1739,7 @@ public class StrUtil {
 	 * 截取分隔字符串之前的字符串，不包括分隔字符串<br>
 	 * 如果给定的字符串为空串（null或""）或者分隔字符串为null，返回原字符串<br>
 	 * 如果分隔字符串为空串""，则返回空串，如果分隔字符串未找到，返回原字符串，举例如下：
-	 * 
+	 *
 	 * <pre>
 	 * StrUtil.subBefore(null, *)      = null
 	 * StrUtil.subBefore("", *)        = ""
@@ -1749,9 +1750,9 @@ public class StrUtil {
 	 * StrUtil.subBefore("abc", "")    = ""
 	 * StrUtil.subBefore("abc", null)  = "abc"
 	 * </pre>
-	 * 
-	 * @param string 被查找的字符串
-	 * @param separator 分隔字符串（不包括）
+	 *
+	 * @param string          被查找的字符串
+	 * @param separator       分隔字符串（不包括）
 	 * @param isLastSeparator 是否查找最后一个分隔字符串（多次出现分隔字符串时选取最后一个），true为选取最后一个
 	 * @return 切割后的字符串
 	 * @since 3.1.1
@@ -1780,7 +1781,7 @@ public class StrUtil {
 	 * 截取分隔字符串之前的字符串，不包括分隔字符串<br>
 	 * 如果给定的字符串为空串（null或""）或者分隔字符串为null，返回原字符串<br>
 	 * 如果分隔字符串未找到，返回原字符串，举例如下：
-	 * 
+	 *
 	 * <pre>
 	 * StrUtil.subBefore(null, *)      = null
 	 * StrUtil.subBefore("", *)        = ""
@@ -1789,9 +1790,9 @@ public class StrUtil {
 	 * StrUtil.subBefore("abc", 'c')   = "ab"
 	 * StrUtil.subBefore("abc", 'd')   = "abc"
 	 * </pre>
-	 * 
-	 * @param string 被查找的字符串
-	 * @param separator 分隔字符串（不包括）
+	 *
+	 * @param string          被查找的字符串
+	 * @param separator       分隔字符串（不包括）
 	 * @param isLastSeparator 是否查找最后一个分隔字符串（多次出现分隔字符串时选取最后一个），true为选取最后一个
 	 * @return 切割后的字符串
 	 * @since 4.1.15
@@ -1828,8 +1829,8 @@ public class StrUtil {
 	 * StrUtil.subAfter("abc", "")    = "abc"
 	 * </pre>
 	 *
-	 * @param string 被查找的字符串
-	 * @param separator 分隔字符串（不包括）
+	 * @param string          被查找的字符串
+	 * @param separator       分隔字符串（不包括）
 	 * @param isLastSeparator 是否查找最后一个分隔字符串（多次出现分隔字符串时选取最后一个），true为选取最后一个
 	 * @return 切割后的字符串
 	 * @since 3.1.1
@@ -1864,8 +1865,8 @@ public class StrUtil {
 	 * StrUtil.subAfter("abc", 'd')   = ""
 	 * </pre>
 	 *
-	 * @param string 被查找的字符串
-	 * @param separator 分隔字符串（不包括）
+	 * @param string          被查找的字符串
+	 * @param separator       分隔字符串（不包括）
 	 * @param isLastSeparator 是否查找最后一个分隔字符串（多次出现分隔字符串时选取最后一个），true为选取最后一个
 	 * @return 切割后的字符串
 	 * @since 4.1.15
@@ -1884,9 +1885,9 @@ public class StrUtil {
 
 	/**
 	 * 截取指定字符串中间部分，不包括标识字符串<br>
-	 * 
+	 * <p>
 	 * 栗子：
-	 * 
+	 *
 	 * <pre>
 	 * StrUtil.subBetween("wx[b]yz", "[", "]") = "b"
 	 * StrUtil.subBetween(null, *, *)          = null
@@ -1899,10 +1900,10 @@ public class StrUtil {
 	 * StrUtil.subBetween("yabcz", "y", "z")   = "abc"
 	 * StrUtil.subBetween("yabczyabcz", "y", "z")   = "abc"
 	 * </pre>
-	 * 
-	 * @param str 被切割的字符串
+	 *
+	 * @param str    被切割的字符串
 	 * @param before 截取开始的字符串标识
-	 * @param after 截取到的字符串标识
+	 * @param after  截取到的字符串标识
 	 * @return 截取后的字符串
 	 * @since 3.1.1
 	 */
@@ -1927,9 +1928,9 @@ public class StrUtil {
 
 	/**
 	 * 截取指定字符串中间部分，不包括标识字符串<br>
-	 * 
+	 * <p>
 	 * 栗子：
-	 * 
+	 *
 	 * <pre>
 	 * StrUtil.subBetween(null, *)            = null
 	 * StrUtil.subBetween("", "")             = ""
@@ -1938,8 +1939,8 @@ public class StrUtil {
 	 * StrUtil.subBetween("tagabctag", "")    = ""
 	 * StrUtil.subBetween("tagabctag", "tag") = "abc"
 	 * </pre>
-	 * 
-	 * @param str 被切割的字符串
+	 *
+	 * @param str            被切割的字符串
 	 * @param beforeAndAfter 截取开始和结束的字符串标识
 	 * @return 截取后的字符串
 	 * @since 3.1.1
@@ -1950,7 +1951,7 @@ public class StrUtil {
 
 	/**
 	 * 截取指定字符串多段中间部分，不包括标识字符串<br>
-	 *
+	 * <p>
 	 * 栗子：
 	 *
 	 * <pre>
@@ -1967,46 +1968,44 @@ public class StrUtil {
 	 * StrUtil.subBetweenAll("[yabc[zy]abcz]", "[", "]");   = ["zy"]           重叠时只截取内部，
 	 * </pre>
 	 *
-	 * @param str 被切割的字符串
-	 * @param regexBefore 截取开始的字符串标识
-	 * @param regexAfter 截取到的字符串标识
+	 * @param str         被切割的字符串
+	 * @param prefix 截取开始的字符串标识
+	 * @param suffix  截取到的字符串标识
 	 * @return 截取后的字符串
 	 * @author dahuoyzs
 	 * @since 5.2.5
 	 */
-	public static String[] subBetweenAll(CharSequence str, CharSequence regexBefore, CharSequence regexAfter) {
-		if (str == null || regexBefore == null || regexAfter == null || str.length() < 1 || regexBefore.length() < 1 || regexAfter.length() < 1) {
+	public static String[] subBetweenAll(CharSequence str, CharSequence prefix, CharSequence suffix) {
+		if(hasEmpty(str, prefix, suffix)) {
 			return new String[0];
 		}
 
-		final String before = regexBefore.toString().replace("\\", "");
-		final String after = regexAfter.toString().replace("\\", "");
-		final Integer beforeNumber = StrUtil.count(str, before);
-		final Integer afterNumber = StrUtil.count(str, after);
-		if (beforeNumber<1||afterNumber<1){
+		final int prefixCount = count(str, prefix);
+		final int suffixCount = count(str, suffix);
+		if (prefixCount < 1 || suffixCount < 1) {
 			return new String[0];
 		}
 
 		LinkedList<String> betweenList = new LinkedList<>();
-		if (beforeNumber.compareTo(afterNumber) > 0) {
-			String[] fragments = str.toString().split(regexAfter.toString());
+		if (prefixCount > suffixCount) {
+			String[] fragments = split(str, suffix);
 			for (int i = 0; i < fragments.length - 1; i++) {
 				String fragment = fragments[i];
-				if (fragment.contains(before)) {
-					int beforeIndex = StrUtil.lastIndexOf(fragment, before, 0, false);
+				if (fragment.contains(prefix)) {
+					int beforeIndex = StrUtil.lastIndexOf(fragment, prefix, 0, false);
 					String between = fragment.substring(beforeIndex);
-					if (between.length()>0)
+					if (between.length() > 0)
 						betweenList.add(between);
 				}
 			}
 		} else {
-			String[] fragments = str.toString().split(regexBefore.toString());
+			String[] fragments = split(str, prefix);
 			for (int i = 1; i < fragments.length; i++) {
 				String fragment = fragments[i];
-				if (fragment.contains(after)) {
-					int afterIndex = StrUtil.indexOf(fragment, after, 0, false);
+				if (fragment.contains(suffix)) {
+					int afterIndex = StrUtil.indexOf(fragment, suffix, 0, false);
 					String between = fragment.substring(0, afterIndex);
-					if (between.length()>0)
+					if (between.length() > 0)
 						betweenList.add(between);
 				}
 			}
@@ -2017,8 +2016,8 @@ public class StrUtil {
 
 	/**
 	 * 给定字符串是否被字符包围
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str    字符串
 	 * @param prefix 前缀
 	 * @param suffix 后缀
 	 * @return 是否包围，空串不包围
@@ -2037,8 +2036,8 @@ public class StrUtil {
 
 	/**
 	 * 给定字符串是否被字符包围
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str    字符串
 	 * @param prefix 前缀
 	 * @param suffix 后缀
 	 * @return 是否包围，空串不包围
@@ -2056,8 +2055,8 @@ public class StrUtil {
 
 	/**
 	 * 重复某个字符
-	 * 
-	 * @param c 被重复的字符
+	 *
+	 * @param c     被重复的字符
 	 * @param count 重复的数目，如果小于等于0则返回""
 	 * @return 重复字符字符串
 	 */
@@ -2075,8 +2074,8 @@ public class StrUtil {
 
 	/**
 	 * 重复某个字符串
-	 * 
-	 * @param str 被重复的字符
+	 *
+	 * @param str   被重复的字符
 	 * @param count 重复的数目
 	 * @return 重复字符字符串
 	 */
@@ -2111,8 +2110,8 @@ public class StrUtil {
 
 	/**
 	 * 重复某个字符串到指定长度
-	 * 
-	 * @param str 被重复的字符
+	 *
+	 * @param str    被重复的字符
 	 * @param padLen 指定长度
 	 * @return 重复字符字符串
 	 * @since 4.3.2
@@ -2141,15 +2140,15 @@ public class StrUtil {
 
 	/**
 	 * 重复某个字符串并通过分界符连接
-	 * 
+	 *
 	 * <pre>
 	 * StrUtil.repeatAndJoin("?", 5, ",")   = "?,?,?,?,?"
 	 * StrUtil.repeatAndJoin("?", 0, ",")   = ""
 	 * StrUtil.repeatAndJoin("?", 5, null) = "?????"
 	 * </pre>
-	 * 
-	 * @param str 被重复的字符串
-	 * @param count 数量
+	 *
+	 * @param str         被重复的字符串
+	 * @param count       数量
 	 * @param conjunction 分界符
 	 * @return 连接后的字符串
 	 * @since 4.0.1
@@ -2173,7 +2172,7 @@ public class StrUtil {
 
 	/**
 	 * 比较两个字符串（大小写敏感）。
-	 * 
+	 *
 	 * <pre>
 	 * equals(null, null)   = true
 	 * equals(null, &quot;abc&quot;)  = false
@@ -2181,10 +2180,9 @@ public class StrUtil {
 	 * equals(&quot;abc&quot;, &quot;abc&quot;) = true
 	 * equals(&quot;abc&quot;, &quot;ABC&quot;) = false
 	 * </pre>
-	 * 
+	 *
 	 * @param str1 要比较的字符串1
 	 * @param str2 要比较的字符串2
-	 * 
 	 * @return 如果两个字符串相同，或者都是<code>null</code>，则返回<code>true</code>
 	 */
 	public static boolean equals(CharSequence str1, CharSequence str2) {
@@ -2193,7 +2191,7 @@ public class StrUtil {
 
 	/**
 	 * 比较两个字符串（大小写不敏感）。
-	 * 
+	 *
 	 * <pre>
 	 * equalsIgnoreCase(null, null)   = true
 	 * equalsIgnoreCase(null, &quot;abc&quot;)  = false
@@ -2201,10 +2199,9 @@ public class StrUtil {
 	 * equalsIgnoreCase(&quot;abc&quot;, &quot;abc&quot;) = true
 	 * equalsIgnoreCase(&quot;abc&quot;, &quot;ABC&quot;) = true
 	 * </pre>
-	 * 
+	 *
 	 * @param str1 要比较的字符串1
 	 * @param str2 要比较的字符串2
-	 * 
 	 * @return 如果两个字符串相同，或者都是<code>null</code>，则返回<code>true</code>
 	 */
 	public static boolean equalsIgnoreCase(CharSequence str1, CharSequence str2) {
@@ -2213,9 +2210,9 @@ public class StrUtil {
 
 	/**
 	 * 比较两个字符串是否相等。
-	 * 
-	 * @param str1 要比较的字符串1
-	 * @param str2 要比较的字符串2
+	 *
+	 * @param str1       要比较的字符串1
+	 * @param str2       要比较的字符串2
 	 * @param ignoreCase 是否忽略大小写
 	 * @return 如果两个字符串相同，或者都是<code>null</code>，则返回<code>true</code>
 	 * @since 3.2.0
@@ -2240,7 +2237,7 @@ public class StrUtil {
 	/**
 	 * 给定字符串是否与提供的中任一字符串相同（忽略大小写），相同则返回{@code true}，没有相同的返回{@code false}<br>
 	 * 如果参与比对的字符串列表为空，返回{@code false}
-	 * 
+	 *
 	 * @param str1 给定需要检查的字符串
 	 * @param strs 需要参与比对的字符串列表
 	 * @return 是否相同
@@ -2253,7 +2250,7 @@ public class StrUtil {
 	/**
 	 * 给定字符串是否与提供的中任一字符串相同，相同则返回{@code true}，没有相同的返回{@code false}<br>
 	 * 如果参与比对的字符串列表为空，返回{@code false}
-	 * 
+	 *
 	 * @param str1 给定需要检查的字符串
 	 * @param strs 需要参与比对的字符串列表
 	 * @return 是否相同
@@ -2266,10 +2263,10 @@ public class StrUtil {
 	/**
 	 * 给定字符串是否与提供的中任一字符串相同，相同则返回{@code true}，没有相同的返回{@code false}<br>
 	 * 如果参与比对的字符串列表为空，返回{@code false}
-	 * 
-	 * @param str1 给定需要检查的字符串
+	 *
+	 * @param str1       给定需要检查的字符串
 	 * @param ignoreCase 是否忽略大小写
-	 * @param strs 需要参与比对的字符串列表
+	 * @param strs       需要参与比对的字符串列表
 	 * @return 是否相同
 	 * @since 4.3.2
 	 */
@@ -2294,9 +2291,9 @@ public class StrUtil {
 	 * 通常使用：format("this is {} for {}", "a", "b") =》 this is a for b<br>
 	 * 转义{}： format("this is \\{} for {}", "a", "b") =》 this is \{} for a<br>
 	 * 转义\： format("this is \\\\{} for {}", "a", "b") =》 this is \a for b<br>
-	 * 
+	 *
 	 * @param template 文本模板，被替换的部分用 {} 表示
-	 * @param params 参数值
+	 * @param params   参数值
 	 * @return 格式化后的文本
 	 */
 	public static String format(CharSequence template, Object... params) {
@@ -2313,8 +2310,8 @@ public class StrUtil {
 	 * 有序的格式化文本，使用{number}做为占位符<br>
 	 * 例：<br>
 	 * 通常使用：format("this is {0} for {1}", "a", "b") =》 this is a for b<br>
-	 * 
-	 * @param pattern 文本格式
+	 *
+	 * @param pattern   文本格式
 	 * @param arguments 参数
 	 * @return 格式化后的文本
 	 */
@@ -2325,9 +2322,9 @@ public class StrUtil {
 	/**
 	 * 格式化文本，使用 {varName} 占位<br>
 	 * map = {a: "aValue", b: "bValue"} format("{a} and {b}", map) ---=》 aValue and bValue
-	 * 
+	 *
 	 * @param template 文本模板，被替换的部分用 {key} 表示
-	 * @param map 参数值对
+	 * @param map      参数值对
 	 * @return 格式化后的文本
 	 */
 	public static String format(CharSequence template, Map<?, ?> map) {
@@ -2351,7 +2348,7 @@ public class StrUtil {
 
 	/**
 	 * 编码字符串，编码为UTF-8
-	 * 
+	 *
 	 * @param str 字符串
 	 * @return 编码后的字节码
 	 */
@@ -2362,7 +2359,7 @@ public class StrUtil {
 	/**
 	 * 编码字符串<br>
 	 * 使用系统默认编码
-	 * 
+	 *
 	 * @param str 字符串
 	 * @return 编码后的字节码
 	 */
@@ -2372,8 +2369,8 @@ public class StrUtil {
 
 	/**
 	 * 编码字符串
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str     字符串
 	 * @param charset 字符集，如果此字段为空，则解码的结果取决于平台
 	 * @return 编码后的字节码
 	 */
@@ -2383,8 +2380,8 @@ public class StrUtil {
 
 	/**
 	 * 编码字符串
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str     字符串
 	 * @param charset 字符集，如果此字段为空，则解码的结果取决于平台
 	 * @return 编码后的字节码
 	 */
@@ -2402,7 +2399,7 @@ public class StrUtil {
 	/**
 	 * 将对象转为字符串<br>
 	 * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
-	 * 
+	 *
 	 * @param obj 对象
 	 * @return 字符串
 	 */
@@ -2413,8 +2410,8 @@ public class StrUtil {
 	/**
 	 * 将对象转为字符串<br>
 	 * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
-	 * 
-	 * @param obj 对象
+	 *
+	 * @param obj         对象
 	 * @param charsetName 字符集
 	 * @return 字符串
 	 */
@@ -2425,8 +2422,8 @@ public class StrUtil {
 	/**
 	 * 将对象转为字符串<br>
 	 * 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
-	 * 
-	 * @param obj 对象
+	 *
+	 * @param obj     对象
 	 * @param charset 字符集
 	 * @return 字符串
 	 */
@@ -2452,8 +2449,8 @@ public class StrUtil {
 
 	/**
 	 * 将byte数组转为字符串
-	 * 
-	 * @param bytes byte数组
+	 *
+	 * @param bytes   byte数组
 	 * @param charset 字符集
 	 * @return 字符串
 	 */
@@ -2463,8 +2460,8 @@ public class StrUtil {
 
 	/**
 	 * 解码字节码
-	 * 
-	 * @param data 字符串
+	 *
+	 * @param data    字符串
 	 * @param charset 字符集，如果此字段为空，则解码的结果取决于平台
 	 * @return 解码后的字符串
 	 */
@@ -2481,8 +2478,8 @@ public class StrUtil {
 
 	/**
 	 * 将Byte数组转为字符串
-	 * 
-	 * @param bytes byte数组
+	 *
+	 * @param bytes   byte数组
 	 * @param charset 字符集
 	 * @return 字符串
 	 */
@@ -2492,8 +2489,8 @@ public class StrUtil {
 
 	/**
 	 * 解码字节码
-	 * 
-	 * @param data 字符串
+	 *
+	 * @param data    字符串
 	 * @param charset 字符集，如果此字段为空，则解码的结果取决于平台
 	 * @return 解码后的字符串
 	 */
@@ -2514,8 +2511,8 @@ public class StrUtil {
 
 	/**
 	 * 将编码的byteBuffer数据转换为字符串
-	 * 
-	 * @param data 数据
+	 *
+	 * @param data    数据
 	 * @param charset 字符集，如果为空使用当前系统字符集
 	 * @return 字符串
 	 */
@@ -2529,8 +2526,8 @@ public class StrUtil {
 
 	/**
 	 * 将编码的byteBuffer数据转换为字符串
-	 * 
-	 * @param data 数据
+	 *
+	 * @param data    数据
 	 * @param charset 字符集，如果为空使用当前系统字符集
 	 * @return 字符串
 	 */
@@ -2543,7 +2540,7 @@ public class StrUtil {
 
 	/**
 	 * {@link CharSequence} 转为字符串，null安全
-	 * 
+	 *
 	 * @param cs {@link CharSequence}
 	 * @return 字符串
 	 */
@@ -2553,7 +2550,7 @@ public class StrUtil {
 
 	/**
 	 * 调用对象的toString方法，null会返回“null”
-	 * 
+	 *
 	 * @param obj 对象
 	 * @return 字符串
 	 * @since 4.1.3
@@ -2564,8 +2561,8 @@ public class StrUtil {
 
 	/**
 	 * 字符串转换为byteBuffer
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str     字符串
 	 * @param charset 编码
 	 * @return byteBuffer
 	 */
@@ -2575,12 +2572,11 @@ public class StrUtil {
 
 	/**
 	 * 以 conjunction 为分隔符将多个对象转换为字符串
-	 * 
-	 * @see ArrayUtil#join(Object, CharSequence)
-	 * 
+	 *
 	 * @param conjunction 分隔符
-	 * @param objs 数组
+	 * @param objs        数组
 	 * @return 连接后的字符串
+	 * @see ArrayUtil#join(Object, CharSequence)
 	 */
 	public static String join(CharSequence conjunction, Object... objs) {
 		return ArrayUtil.join(objs, conjunction);
@@ -2589,7 +2585,7 @@ public class StrUtil {
 	/**
 	 * 将驼峰式命名的字符串转换为下划线方式。如果转换前的驼峰式命名的字符串为空，则返回空字符串。<br>
 	 * 例如：
-	 * 
+	 *
 	 * <pre>
 	 * HelloWorld=》hello_world
 	 * Hello_World=》hello_world
@@ -2606,7 +2602,7 @@ public class StrUtil {
 	/**
 	 * 将驼峰式命名的字符串转换为使用符号连接方式。如果转换前的驼峰式命名的字符串为空，则返回空字符串。<br>
 	 *
-	 * @param str 转换前的驼峰式命名的字符串，也可以为符号连接形式
+	 * @param str    转换前的驼峰式命名的字符串，也可以为符号连接形式
 	 * @param symbol 连接符
 	 * @return 转换后符号连接方式命名的字符串
 	 * @since 4.0.10
@@ -2692,8 +2688,8 @@ public class StrUtil {
 	/**
 	 * 包装指定字符串<br>
 	 * 当前缀和后缀一致时使用此方法
-	 * 
-	 * @param str 被包装的字符串
+	 *
+	 * @param str             被包装的字符串
 	 * @param prefixAndSuffix 前缀和后缀
 	 * @return 包装后的字符串
 	 * @since 3.1.0
@@ -2704,8 +2700,8 @@ public class StrUtil {
 
 	/**
 	 * 包装指定字符串
-	 * 
-	 * @param str 被包装的字符串
+	 *
+	 * @param str    被包装的字符串
 	 * @param prefix 前缀
 	 * @param suffix 后缀
 	 * @return 包装后的字符串
@@ -2716,9 +2712,9 @@ public class StrUtil {
 
 	/**
 	 * 包装多个字符串
-	 * 
+	 *
 	 * @param prefixAndSuffix 前缀和后缀
-	 * @param strs 多个字符串
+	 * @param strs            多个字符串
 	 * @return 包装的字符串数组
 	 * @since 4.0.7
 	 */
@@ -2728,10 +2724,10 @@ public class StrUtil {
 
 	/**
 	 * 包装多个字符串
-	 * 
+	 *
 	 * @param prefix 前缀
 	 * @param suffix 后缀
-	 * @param strs 多个字符串
+	 * @param strs   多个字符串
 	 * @return 包装的字符串数组
 	 * @since 4.0.7
 	 */
@@ -2745,8 +2741,8 @@ public class StrUtil {
 
 	/**
 	 * 包装指定字符串，如果前缀或后缀已经包含对应的字符串，则不再包装
-	 * 
-	 * @param str 被包装的字符串
+	 *
+	 * @param str    被包装的字符串
 	 * @param prefix 前缀
 	 * @param suffix 后缀
 	 * @return 包装后的字符串
@@ -2777,9 +2773,9 @@ public class StrUtil {
 
 	/**
 	 * 包装多个字符串，如果已经包装，则不再包装
-	 * 
+	 *
 	 * @param prefixAndSuffix 前缀和后缀
-	 * @param strs 多个字符串
+	 * @param strs            多个字符串
 	 * @return 包装的字符串数组
 	 * @since 4.0.7
 	 */
@@ -2789,10 +2785,10 @@ public class StrUtil {
 
 	/**
 	 * 包装多个字符串，如果已经包装，则不再包装
-	 * 
+	 *
 	 * @param prefix 前缀
 	 * @param suffix 后缀
-	 * @param strs 多个字符串
+	 * @param strs   多个字符串
 	 * @return 包装的字符串数组
 	 * @since 4.0.7
 	 */
@@ -2806,8 +2802,8 @@ public class StrUtil {
 
 	/**
 	 * 去掉字符包装，如果未被包装则返回原字符串
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str    字符串
 	 * @param prefix 前置字符串
 	 * @param suffix 后置字符串
 	 * @return 去掉包装字符的字符串
@@ -2822,8 +2818,8 @@ public class StrUtil {
 
 	/**
 	 * 去掉字符包装，如果未被包装则返回原字符串
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str    字符串
 	 * @param prefix 前置字符
 	 * @param suffix 后置字符
 	 * @return 去掉包装字符的字符串
@@ -2841,8 +2837,8 @@ public class StrUtil {
 
 	/**
 	 * 去掉字符包装，如果未被包装则返回原字符串
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str             字符串
 	 * @param prefixAndSuffix 前置和后置字符
 	 * @return 去掉包装字符的字符串
 	 * @since 4.0.1
@@ -2853,8 +2849,8 @@ public class StrUtil {
 
 	/**
 	 * 指定字符串是否被包装
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str    字符串
 	 * @param prefix 前缀
 	 * @param suffix 后缀
 	 * @return 是否被包装
@@ -2869,8 +2865,8 @@ public class StrUtil {
 
 	/**
 	 * 指定字符串是否被同一字符包装（前后都有这些字符串）
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str     字符串
 	 * @param wrapper 包装字符串
 	 * @return 是否被包装
 	 */
@@ -2880,8 +2876,8 @@ public class StrUtil {
 
 	/**
 	 * 指定字符串是否被同一字符包装（前后都有这些字符串）
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str     字符串
 	 * @param wrapper 包装字符
 	 * @return 是否被包装
 	 */
@@ -2891,8 +2887,8 @@ public class StrUtil {
 
 	/**
 	 * 指定字符串是否被包装
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str        字符串
 	 * @param prefixChar 前缀
 	 * @param suffixChar 后缀
 	 * @return 是否被包装
@@ -2907,16 +2903,16 @@ public class StrUtil {
 
 	/**
 	 * 补充字符串以满足最小长度
-	 * 
+	 *
 	 * <pre>
 	 * StrUtil.padPre(null, *, *);//null
 	 * StrUtil.padPre("1", 3, "ABC");//"AB1"
 	 * StrUtil.padPre("123", 2, "ABC");//"12"
 	 * </pre>
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str       字符串
 	 * @param minLength 最小长度
-	 * @param padStr 补充的字符
+	 * @param padStr    补充的字符
 	 * @return 补充后的字符串
 	 */
 	public static String padPre(CharSequence str, int minLength, CharSequence padStr) {
@@ -2935,16 +2931,16 @@ public class StrUtil {
 
 	/**
 	 * 补充字符串以满足最小长度
-	 * 
+	 *
 	 * <pre>
 	 * StrUtil.padPre(null, *, *);//null
 	 * StrUtil.padPre("1", 3, '0');//"001"
 	 * StrUtil.padPre("123", 2, '0');//"12"
 	 * </pre>
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str       字符串
 	 * @param minLength 最小长度
-	 * @param padChar 补充的字符
+	 * @param padChar   补充的字符
 	 * @return 补充后的字符串
 	 */
 	public static String padPre(CharSequence str, int minLength, char padChar) {
@@ -2963,16 +2959,16 @@ public class StrUtil {
 
 	/**
 	 * 补充字符串以满足最小长度
-	 * 
+	 *
 	 * <pre>
 	 * StrUtil.padAfter(null, *, *);//null
 	 * StrUtil.padAfter("1", 3, '0');//"100"
 	 * StrUtil.padAfter("123", 2, '0');//"23"
 	 * </pre>
-	 * 
-	 * @param str 字符串，如果为<code>null</code>，按照空串处理
+	 *
+	 * @param str       字符串，如果为<code>null</code>，按照空串处理
 	 * @param minLength 最小长度
-	 * @param padChar 补充的字符
+	 * @param padChar   补充的字符
 	 * @return 补充后的字符串
 	 */
 	public static String padAfter(CharSequence str, int minLength, char padChar) {
@@ -2991,16 +2987,16 @@ public class StrUtil {
 
 	/**
 	 * 补充字符串以满足最小长度
-	 * 
+	 *
 	 * <pre>
 	 * StrUtil.padAfter(null, *, *);//null
 	 * StrUtil.padAfter("1", 3, "ABC");//"1AB"
 	 * StrUtil.padAfter("123", 2, "ABC");//"23"
 	 * </pre>
-	 * 
-	 * @param str 字符串，如果为<code>null</code>，按照空串处理
+	 *
+	 * @param str       字符串，如果为<code>null</code>，按照空串处理
 	 * @param minLength 最小长度
-	 * @param padStr 补充的字符
+	 * @param padStr    补充的字符
 	 * @return 补充后的字符串
 	 * @since 4.3.2
 	 */
@@ -3020,7 +3016,7 @@ public class StrUtil {
 
 	/**
 	 * 居中字符串，两边补充指定字符串，如果指定长度小于字符串，则返回原字符串
-	 * 
+	 *
 	 * <pre>
 	 * StrUtil.center(null, *)   = null
 	 * StrUtil.center("", 4)     = "    "
@@ -3030,7 +3026,7 @@ public class StrUtil {
 	 * StrUtil.center("a", 4)    = " a  "
 	 * </pre>
 	 *
-	 * @param str 字符串
+	 * @param str  字符串
 	 * @param size 指定长度
 	 * @return 补充后的字符串
 	 * @since 4.3.2
@@ -3041,7 +3037,7 @@ public class StrUtil {
 
 	/**
 	 * 居中字符串，两边补充指定字符串，如果指定长度小于字符串，则返回原字符串
-	 * 
+	 *
 	 * <pre>
 	 * StrUtil.center(null, *, *)     = null
 	 * StrUtil.center("", 4, ' ')     = "    "
@@ -3053,8 +3049,8 @@ public class StrUtil {
 	 * StrUtil.center("abc", 7, ' ')   = "  abc  "
 	 * </pre>
 	 *
-	 * @param str 字符串
-	 * @param size 指定长度
+	 * @param str     字符串
+	 * @param size    指定长度
 	 * @param padChar 两边补充的字符
 	 * @return 补充后的字符串
 	 * @since 4.3.2
@@ -3075,7 +3071,7 @@ public class StrUtil {
 
 	/**
 	 * 居中字符串，两边补充指定字符串，如果指定长度小于字符串，则返回原字符串
-	 * 
+	 *
 	 * <pre>
 	 * StrUtil.center(null, *, *)     = null
 	 * StrUtil.center("", 4, " ")     = "    "
@@ -3088,8 +3084,8 @@ public class StrUtil {
 	 * StrUtil.center("abc", 7, "")   = "  abc  "
 	 * </pre>
 	 *
-	 * @param str 字符串
-	 * @param size 指定长度
+	 * @param str    字符串
+	 * @param size   指定长度
 	 * @param padStr 两边补充的字符串
 	 * @return 补充后的字符串
 	 */
@@ -3112,7 +3108,7 @@ public class StrUtil {
 
 	/**
 	 * 创建StringBuilder对象
-	 * 
+	 *
 	 * @return StringBuilder对象
 	 */
 	public static StringBuilder builder() {
@@ -3121,7 +3117,7 @@ public class StrUtil {
 
 	/**
 	 * 创建StrBuilder对象
-	 * 
+	 *
 	 * @return StrBuilder对象
 	 * @since 4.0.1
 	 */
@@ -3131,7 +3127,7 @@ public class StrUtil {
 
 	/**
 	 * 创建StringBuilder对象
-	 * 
+	 *
 	 * @param capacity 初始大小
 	 * @return StringBuilder对象
 	 */
@@ -3141,7 +3137,7 @@ public class StrUtil {
 
 	/**
 	 * 创建StrBuilder对象
-	 * 
+	 *
 	 * @param capacity 初始大小
 	 * @return StrBuilder对象
 	 * @since 4.0.1
@@ -3152,7 +3148,7 @@ public class StrUtil {
 
 	/**
 	 * 创建StringBuilder对象
-	 * 
+	 *
 	 * @param strs 初始字符串列表
 	 * @return StringBuilder对象
 	 */
@@ -3166,7 +3162,7 @@ public class StrUtil {
 
 	/**
 	 * 创建StrBuilder对象
-	 * 
+	 *
 	 * @param strs 初始字符串列表
 	 * @return StrBuilder对象
 	 */
@@ -3176,7 +3172,7 @@ public class StrUtil {
 
 	/**
 	 * 获得StringReader
-	 * 
+	 *
 	 * @param str 字符串
 	 * @return StringReader
 	 */
@@ -3189,7 +3185,7 @@ public class StrUtil {
 
 	/**
 	 * 获得StringWriter
-	 * 
+	 *
 	 * @return StringWriter
 	 */
 	public static StringWriter getWriter() {
@@ -3210,7 +3206,7 @@ public class StrUtil {
 	 * StrUtil.count("abba", "xxx") = 0
 	 * </pre>
 	 *
-	 * @param content 被查找的字符串
+	 * @param content      被查找的字符串
 	 * @param strForSearch 需要查找的字符串
 	 * @return 查找到的个数
 	 */
@@ -3232,8 +3228,8 @@ public class StrUtil {
 
 	/**
 	 * 统计指定内容中包含指定字符的数量
-	 * 
-	 * @param content 内容
+	 *
+	 * @param content       内容
 	 * @param charForSearch 被统计的字符
 	 * @return 包含数量
 	 */
@@ -3253,8 +3249,8 @@ public class StrUtil {
 
 	/**
 	 * 将字符串切分为N等份
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str        字符串
 	 * @param partLength 每等份的长度
 	 * @return 切分后的数组
 	 * @since 3.0.6
@@ -3265,7 +3261,7 @@ public class StrUtil {
 		}
 		int len = str.length();
 		if (len < partLength) {
-			return new String[] { str.toString() };
+			return new String[]{str.toString()};
 		}
 		int part = NumberUtil.count(len, partLength);
 		final String[] array = new String[part];
@@ -3279,8 +3275,8 @@ public class StrUtil {
 
 	/**
 	 * 将给定字符串，变成 "xxx...xxx" 形式的字符串
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str       字符串
 	 * @param maxLength 最大长度
 	 * @return 截取后的字符串
 	 */
@@ -3300,7 +3296,7 @@ public class StrUtil {
 
 	/**
 	 * 比较两个字符串，用于排序
-	 * 
+	 *
 	 * <pre>
 	 * StrUtil.compare(null, null, *)     = 0
 	 * StrUtil.compare(null , "a", true)  &lt; 0
@@ -3313,9 +3309,9 @@ public class StrUtil {
 	 * StrUtil.compare("a", "B", *)       &gt; 0
 	 * StrUtil.compare("ab", "abc", *)    &lt; 0
 	 * </pre>
-	 * 
-	 * @param str1 字符串1
-	 * @param str2 字符串2
+	 *
+	 * @param str1       字符串1
+	 * @param str2       字符串2
 	 * @param nullIsLess {@code null} 值是否排在前（null是否小于非空值）
 	 * @return 排序值。负数：str1 &lt; str2，正数：str1 &gt; str2, 0：str1 == str2
 	 */
@@ -3334,7 +3330,7 @@ public class StrUtil {
 
 	/**
 	 * 比较两个字符串，用于排序，大小写不敏感
-	 * 
+	 *
 	 * <pre>
 	 * StrUtil.compareIgnoreCase(null, null, *)     = 0
 	 * StrUtil.compareIgnoreCase(null , "a", true)  &lt; 0
@@ -3349,9 +3345,9 @@ public class StrUtil {
 	 * StrUtil.compareIgnoreCase("A", "b", *)       &lt; 0
 	 * StrUtil.compareIgnoreCase("ab", "abc", *)    &lt; 0
 	 * </pre>
-	 * 
-	 * @param str1 字符串1
-	 * @param str2 字符串2
+	 *
+	 * @param str1       字符串1
+	 * @param str2       字符串2
 	 * @param nullIsLess {@code null} 值是否排在前（null是否小于非空值）
 	 * @return 排序值。负数：str1 &lt; str2，正数：str1 &gt; str2, 0：str1 == str2
 	 */
@@ -3371,7 +3367,7 @@ public class StrUtil {
 	/**
 	 * 比较两个版本<br>
 	 * null版本排在最小：即：
-	 * 
+	 *
 	 * <pre>
 	 * StrUtil.compareVersion(null, "v1") &lt; 0
 	 * StrUtil.compareVersion("v1", "v1")  = 0
@@ -3382,7 +3378,7 @@ public class StrUtil {
 	 * StrUtil.compareVersion("1.13.0", "1.12.1c") &gt; 0
 	 * StrUtil.compareVersion("V0.0.20170102", "V0.0.20170101") &gt; 0
 	 * </pre>
-	 * 
+	 *
 	 * @param version1 版本1
 	 * @param version2 版本2
 	 * @return 排序值。负数：version1 &lt; version2，正数：version1 &gt; version2, 0：version1 == version2
@@ -3394,8 +3390,8 @@ public class StrUtil {
 
 	/**
 	 * 指定范围内查找指定字符
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str        字符串
 	 * @param searchChar 被查找的字符
 	 * @return 位置
 	 */
@@ -3405,10 +3401,10 @@ public class StrUtil {
 
 	/**
 	 * 指定范围内查找指定字符
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str        字符串
 	 * @param searchChar 被查找的字符
-	 * @param start 起始位置，如果小于0，从0开始查找
+	 * @param start      起始位置，如果小于0，从0开始查找
 	 * @return 位置
 	 */
 	public static int indexOf(final CharSequence str, char searchChar, int start) {
@@ -3421,11 +3417,11 @@ public class StrUtil {
 
 	/**
 	 * 指定范围内查找指定字符
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str        字符串
 	 * @param searchChar 被查找的字符
-	 * @param start 起始位置，如果小于0，从0开始查找
-	 * @param end 终止位置，如果超过str.length()则默认查找到字符串末尾
+	 * @param start      起始位置，如果小于0，从0开始查找
+	 * @param end        终止位置，如果超过str.length()则默认查找到字符串末尾
 	 * @return 位置
 	 */
 	public static int indexOf(final CharSequence str, char searchChar, int start, int end) {
@@ -3446,7 +3442,7 @@ public class StrUtil {
 
 	/**
 	 * 指定范围内查找字符串，忽略大小写<br>
-	 * 
+	 *
 	 * <pre>
 	 * StrUtil.indexOfIgnoreCase(null, *, *)          = -1
 	 * StrUtil.indexOfIgnoreCase(*, null, *)          = -1
@@ -3460,8 +3456,8 @@ public class StrUtil {
 	 * StrUtil.indexOfIgnoreCase("aabaabaa", "", 2)   = 2
 	 * StrUtil.indexOfIgnoreCase("abc", "", 9)        = -1
 	 * </pre>
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str       字符串
 	 * @param searchStr 需要查找位置的字符串
 	 * @return 位置
 	 * @since 3.2.1
@@ -3472,7 +3468,7 @@ public class StrUtil {
 
 	/**
 	 * 指定范围内查找字符串
-	 * 
+	 *
 	 * <pre>
 	 * StrUtil.indexOfIgnoreCase(null, *, *)          = -1
 	 * StrUtil.indexOfIgnoreCase(*, null, *)          = -1
@@ -3486,8 +3482,8 @@ public class StrUtil {
 	 * StrUtil.indexOfIgnoreCase("aabaabaa", "", 2)   = 2
 	 * StrUtil.indexOfIgnoreCase("abc", "", 9)        = -1
 	 * </pre>
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str       字符串
 	 * @param searchStr 需要查找位置的字符串
 	 * @param fromIndex 起始位置
 	 * @return 位置
@@ -3499,10 +3495,10 @@ public class StrUtil {
 
 	/**
 	 * 指定范围内查找字符串
-	 * 
-	 * @param str 字符串
-	 * @param searchStr 需要查找位置的字符串
-	 * @param fromIndex 起始位置
+	 *
+	 * @param str        字符串
+	 * @param searchStr  需要查找位置的字符串
+	 * @param fromIndex  起始位置
 	 * @param ignoreCase 是否忽略大小写
 	 * @return 位置
 	 * @since 3.2.1
@@ -3538,8 +3534,8 @@ public class StrUtil {
 
 	/**
 	 * 指定范围内查找字符串，忽略大小写
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str       字符串
 	 * @param searchStr 需要查找位置的字符串
 	 * @return 位置
 	 * @since 3.2.1
@@ -3551,8 +3547,8 @@ public class StrUtil {
 	/**
 	 * 指定范围内查找字符串，忽略大小写<br>
 	 * fromIndex 为搜索起始位置，从后往前计数
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str       字符串
 	 * @param searchStr 需要查找位置的字符串
 	 * @param fromIndex 起始位置，从后往前计数
 	 * @return 位置
@@ -3565,10 +3561,10 @@ public class StrUtil {
 	/**
 	 * 指定范围内查找字符串<br>
 	 * fromIndex 为搜索起始位置，从后往前计数
-	 * 
-	 * @param str 字符串
-	 * @param searchStr 需要查找位置的字符串
-	 * @param fromIndex 起始位置，从后往前计数
+	 *
+	 * @param str        字符串
+	 * @param searchStr  需要查找位置的字符串
+	 * @param fromIndex  起始位置，从后往前计数
 	 * @param ignoreCase 是否忽略大小写
 	 * @return 位置
 	 * @since 3.2.1
@@ -3605,9 +3601,9 @@ public class StrUtil {
 	 * <p>
 	 * 如果 str=null 或 searchStr=null 或 ordinal&ge;0 则返回-1<br>
 	 * 此方法来自：Apache-Commons-Lang
-	 * 
+	 * <p>
 	 * 例子（*代表任意字符）：
-	 * 
+	 *
 	 * <pre>
 	 * StrUtil.ordinalIndexOf(null, *, *)          = -1
 	 * StrUtil.ordinalIndexOf(*, null, *)          = -1
@@ -3622,9 +3618,9 @@ public class StrUtil {
 	 * StrUtil.ordinalIndexOf("aabaabaa", "", 2)   = 0
 	 * </pre>
 	 *
-	 * @param str 被检查的字符串，可以为null
+	 * @param str       被检查的字符串，可以为null
 	 * @param searchStr 被查找的字符串，可以为null
-	 * @param ordinal 第几次出现的位置
+	 * @param ordinal   第几次出现的位置
 	 * @return 查找到的位置
 	 * @since 3.2.3
 	 */
@@ -3648,14 +3644,14 @@ public class StrUtil {
 	}
 
 	// ------------------------------------------------------------------------------------------------------------------ Append and prepend
+
 	/**
 	 * 如果给定字符串不是以给定的一个或多个字符串为结尾，则在尾部添加结尾字符串<br>
 	 * 不忽略大小写
 	 *
-	 * @param str 被检查的字符串
-	 * @param suffix 需要添加到结尾的字符串
+	 * @param str      被检查的字符串
+	 * @param suffix   需要添加到结尾的字符串
 	 * @param suffixes 需要额外检查的结尾字符串，如果以这些中的一个为结尾，则不再添加
-	 *
 	 * @return 如果已经结尾，返回原字符串，否则返回添加结尾的字符串
 	 * @since 3.0.7
 	 */
@@ -3667,10 +3663,9 @@ public class StrUtil {
 	 * 如果给定字符串不是以给定的一个或多个字符串为结尾，则在尾部添加结尾字符串<br>
 	 * 忽略大小写
 	 *
-	 * @param str 被检查的字符串
-	 * @param suffix 需要添加到结尾的字符串
+	 * @param str      被检查的字符串
+	 * @param suffix   需要添加到结尾的字符串
 	 * @param suffixes 需要额外检查的结尾字符串，如果以这些中的一个为结尾，则不再添加
-	 *
 	 * @return 如果已经结尾，返回原字符串，否则返回添加结尾的字符串
 	 * @since 3.0.7
 	 */
@@ -3681,11 +3676,10 @@ public class StrUtil {
 	/**
 	 * 如果给定字符串不是以给定的一个或多个字符串为结尾，则在尾部添加结尾字符串
 	 *
-	 * @param str 被检查的字符串
-	 * @param suffix 需要添加到结尾的字符串
+	 * @param str        被检查的字符串
+	 * @param suffix     需要添加到结尾的字符串
 	 * @param ignoreCase 检查结尾时是否忽略大小写
-	 * @param suffixes 需要额外检查的结尾字符串，如果以这些中的一个为结尾，则不再添加
-	 *
+	 * @param suffixes   需要额外检查的结尾字符串，如果以这些中的一个为结尾，则不再添加
 	 * @return 如果已经结尾，返回原字符串，否则返回添加结尾的字符串
 	 * @since 3.0.7
 	 */
@@ -3707,10 +3701,9 @@ public class StrUtil {
 	 * 如果给定字符串不是以给定的一个或多个字符串为开头，则在首部添加起始字符串<br>
 	 * 不忽略大小写
 	 *
-	 * @param str 被检查的字符串
-	 * @param prefix 需要添加到首部的字符串
+	 * @param str      被检查的字符串
+	 * @param prefix   需要添加到首部的字符串
 	 * @param prefixes 需要额外检查的首部字符串，如果以这些中的一个为起始，则不再添加
-	 *
 	 * @return 如果已经结尾，返回原字符串，否则返回添加结尾的字符串
 	 * @since 3.0.7
 	 */
@@ -3722,10 +3715,9 @@ public class StrUtil {
 	 * 如果给定字符串不是以给定的一个或多个字符串为开头，则在首部添加起始字符串<br>
 	 * 忽略大小写
 	 *
-	 * @param str 被检查的字符串
-	 * @param prefix 需要添加到首部的字符串
+	 * @param str      被检查的字符串
+	 * @param prefix   需要添加到首部的字符串
 	 * @param prefixes 需要额外检查的首部字符串，如果以这些中的一个为起始，则不再添加
-	 *
 	 * @return 如果已经结尾，返回原字符串，否则返回添加结尾的字符串
 	 * @since 3.0.7
 	 */
@@ -3736,11 +3728,10 @@ public class StrUtil {
 	/**
 	 * 如果给定字符串不是以给定的一个或多个字符串为开头，则在首部添加起始字符串
 	 *
-	 * @param str 被检查的字符串
-	 * @param prefix 需要添加到首部的字符串
+	 * @param str        被检查的字符串
+	 * @param prefix     需要添加到首部的字符串
 	 * @param ignoreCase 检查结尾时是否忽略大小写
-	 * @param prefixes 需要额外检查的首部字符串，如果以这些中的一个为起始，则不再添加
-	 *
+	 * @param prefixes   需要额外检查的首部字符串，如果以这些中的一个为起始，则不再添加
 	 * @return 如果已经结尾，返回原字符串，否则返回添加结尾的字符串
 	 * @since 3.0.7
 	 */
@@ -3761,7 +3752,7 @@ public class StrUtil {
 	/**
 	 * 反转字符串<br>
 	 * 例如：abcd =》dcba
-	 * 
+	 *
 	 * @param str 被反转的字符串
 	 * @return 反转后的字符串
 	 * @since 3.0.9
@@ -3773,10 +3764,10 @@ public class StrUtil {
 	/**
 	 * 将已有字符串填充为规定长度，如果已有字符串超过这个长度则返回这个字符串<br>
 	 * 字符填充于字符串前
-	 * 
-	 * @param str 被填充的字符串
+	 *
+	 * @param str        被填充的字符串
 	 * @param filledChar 填充的字符
-	 * @param len 填充长度
+	 * @param len        填充长度
 	 * @return 填充后的字符串
 	 * @since 3.1.2
 	 */
@@ -3787,10 +3778,10 @@ public class StrUtil {
 	/**
 	 * 将已有字符串填充为规定长度，如果已有字符串超过这个长度则返回这个字符串<br>
 	 * 字符填充于字符串后
-	 * 
-	 * @param str 被填充的字符串
+	 *
+	 * @param str        被填充的字符串
 	 * @param filledChar 填充的字符
-	 * @param len 填充长度
+	 * @param len        填充长度
 	 * @return 填充后的字符串
 	 * @since 3.1.2
 	 */
@@ -3800,11 +3791,11 @@ public class StrUtil {
 
 	/**
 	 * 将已有字符串填充为规定长度，如果已有字符串超过这个长度则返回这个字符串
-	 * 
-	 * @param str 被填充的字符串
+	 *
+	 * @param str        被填充的字符串
 	 * @param filledChar 填充的字符
-	 * @param len 填充长度
-	 * @param isPre 是否填充在前
+	 * @param len        填充长度
+	 * @param isPre      是否填充在前
 	 * @return 填充后的字符串
 	 * @since 3.1.2
 	 */
@@ -3821,12 +3812,12 @@ public class StrUtil {
 	/**
 	 * 截取两个字符串的不同部分（长度一致），判断截取的子串是否相同<br>
 	 * 任意一个字符串为null返回false
-	 * 
-	 * @param str1 第一个字符串
-	 * @param start1 第一个字符串开始的位置
-	 * @param str2 第二个字符串
-	 * @param start2 第二个字符串开始的位置
-	 * @param length 截取长度
+	 *
+	 * @param str1       第一个字符串
+	 * @param start1     第一个字符串开始的位置
+	 * @param str2       第二个字符串
+	 * @param start2     第二个字符串开始的位置
+	 * @param length     截取长度
 	 * @param ignoreCase 是否忽略大小写
 	 * @return 子串是否相同
 	 * @since 3.2.1
@@ -3841,8 +3832,8 @@ public class StrUtil {
 
 	/**
 	 * 字符串的每一个字符是否都与定义的匹配器匹配
-	 * 
-	 * @param value 字符串
+	 *
+	 * @param value   字符串
 	 * @param matcher 匹配器
 	 * @return 是否全部匹配
 	 * @since 3.2.3
@@ -3861,9 +3852,9 @@ public class StrUtil {
 
 	/**
 	 * 替换字符串中的指定字符串，忽略大小写
-	 * 
-	 * @param str 字符串
-	 * @param searchStr 被查找的字符串
+	 *
+	 * @param str         字符串
+	 * @param searchStr   被查找的字符串
 	 * @param replacement 被替换的字符串
 	 * @return 替换后的字符串
 	 * @since 4.0.3
@@ -3874,9 +3865,9 @@ public class StrUtil {
 
 	/**
 	 * 替换字符串中的指定字符串
-	 * 
-	 * @param str 字符串
-	 * @param searchStr 被查找的字符串
+	 *
+	 * @param str         字符串
+	 * @param searchStr   被查找的字符串
 	 * @param replacement 被替换的字符串
 	 * @return 替换后的字符串
 	 * @since 4.0.3
@@ -3887,11 +3878,11 @@ public class StrUtil {
 
 	/**
 	 * 替换字符串中的指定字符串
-	 * 
-	 * @param str 字符串
-	 * @param searchStr 被查找的字符串
+	 *
+	 * @param str         字符串
+	 * @param searchStr   被查找的字符串
 	 * @param replacement 被替换的字符串
-	 * @param ignoreCase 是否忽略大小写
+	 * @param ignoreCase  是否忽略大小写
 	 * @return 替换后的字符串
 	 * @since 4.0.3
 	 */
@@ -3901,12 +3892,12 @@ public class StrUtil {
 
 	/**
 	 * 替换字符串中的指定字符串
-	 * 
-	 * @param str 字符串
-	 * @param fromIndex 开始位置（包括）
-	 * @param searchStr 被查找的字符串
+	 *
+	 * @param str         字符串
+	 * @param fromIndex   开始位置（包括）
+	 * @param searchStr   被查找的字符串
 	 * @param replacement 被替换的字符串
-	 * @param ignoreCase 是否忽略大小写
+	 * @param ignoreCase  是否忽略大小写
 	 * @return 替换后的字符串
 	 * @since 4.0.3
 	 */
@@ -3948,10 +3939,10 @@ public class StrUtil {
 
 	/**
 	 * 替换指定字符串的指定区间内字符为固定字符
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str          字符串
 	 * @param startInclude 开始位置（包含）
-	 * @param endExclude 结束位置（不包含）
+	 * @param endExclude   结束位置（不包含）
 	 * @param replacedChar 被替换的字符
 	 * @return 替换后的字符串
 	 * @since 3.2.1
@@ -3985,9 +3976,9 @@ public class StrUtil {
 
 	/**
 	 * 替换所有正则匹配的文本，并使用自定义函数决定如何替换
-	 * 
-	 * @param str 要替换的字符串
-	 * @param pattern 用于匹配的正则式
+	 *
+	 * @param str        要替换的字符串
+	 * @param pattern    用于匹配的正则式
 	 * @param replaceFun 决定如何替换的函数
 	 * @return 替换后的字符串
 	 * @see ReUtil#replaceAll(CharSequence, Pattern, Func1)
@@ -3999,9 +3990,9 @@ public class StrUtil {
 
 	/**
 	 * 替换所有正则匹配的文本，并使用自定义函数决定如何替换
-	 * 
-	 * @param str 要替换的字符串
-	 * @param regex 用于匹配的正则式
+	 *
+	 * @param str        要替换的字符串
+	 * @param regex      用于匹配的正则式
 	 * @param replaceFun 决定如何替换的函数
 	 * @return 替换后的字符串
 	 * @see ReUtil#replaceAll(CharSequence, String, Func1)
@@ -4014,9 +4005,9 @@ public class StrUtil {
 	/**
 	 * 替换指定字符串的指定区间内字符为"*"
 	 *
-	 * @param str 字符串
+	 * @param str          字符串
 	 * @param startInclude 开始位置（包含）
-	 * @param endExclude 结束位置（不包含）
+	 * @param endExclude   结束位置（不包含）
 	 * @return 替换后的字符串
 	 * @since 4.1.14
 	 */
@@ -4027,9 +4018,9 @@ public class StrUtil {
 	/**
 	 * 替换字符字符数组中所有的字符为replacedStr<br>
 	 * 提供的chars为所有需要被替换的字符，例如："\r\n"，则"\r"和"\n"都会被替换，哪怕他们单独存在
-	 * 
-	 * @param str 被检查的字符串
-	 * @param chars 需要替换的字符列表，用一个字符串表示这个字符列表
+	 *
+	 * @param str         被检查的字符串
+	 * @param chars       需要替换的字符列表，用一个字符串表示这个字符列表
 	 * @param replacedStr 替换成的字符串
 	 * @return 新字符串
 	 * @since 3.2.2
@@ -4043,9 +4034,9 @@ public class StrUtil {
 
 	/**
 	 * 替换字符字符数组中所有的字符为replacedStr
-	 * 
-	 * @param str 被检查的字符串
-	 * @param chars 需要替换的字符列表
+	 *
+	 * @param str         被检查的字符串
+	 * @param chars       需要替换的字符列表
 	 * @param replacedStr 替换成的字符串
 	 * @return 新字符串
 	 * @since 3.2.2
@@ -4071,7 +4062,7 @@ public class StrUtil {
 
 	/**
 	 * 计算两个字符串的相似度
-	 * 
+	 *
 	 * @param str1 字符串1
 	 * @param str2 字符串2
 	 * @return 相似度
@@ -4083,9 +4074,9 @@ public class StrUtil {
 
 	/**
 	 * 计算连个字符串的相似度百分比
-	 * 
-	 * @param str1 字符串1
-	 * @param str2 字符串2
+	 *
+	 * @param str1  字符串1
+	 * @param str2  字符串2
 	 * @param scale 相似度
 	 * @return 相似度百分比
 	 * @since 3.2.3
@@ -4099,10 +4090,10 @@ public class StrUtil {
 	 * 如果字符串为null，返回false<br>
 	 * 如果给定的位置大于字符串长度，返回false<br>
 	 * 如果给定的位置小于0，返回false
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str      字符串
 	 * @param position 位置
-	 * @param c 需要对比的字符
+	 * @param c        需要对比的字符
 	 * @return 字符串指定位置的字符是否与给定字符相同
 	 * @since 3.3.1
 	 */
@@ -4116,7 +4107,7 @@ public class StrUtil {
 	/**
 	 * 给定字符串数组的总长度<br>
 	 * null字符长度定义为0
-	 * 
+	 *
 	 * @param strs 字符串数组
 	 * @return 总长度
 	 * @since 4.0.1
@@ -4133,11 +4124,11 @@ public class StrUtil {
 	 * 循环位移指定位置的字符串为指定距离<br>
 	 * 当moveLength大于0向右位移，小于0向左位移，0不位移<br>
 	 * 当moveLength大于字符串长度时采取循环位移策略，即位移到头后从头（尾）位移，例如长度为10，位移13则表示位移3
-	 * 
-	 * @param str 字符串
+	 *
+	 * @param str          字符串
 	 * @param startInclude 起始位置（包括）
-	 * @param endExclude 结束位置（不包括）
-	 * @param moveLength 移动距离，负数表示左移，正数为右移
+	 * @param endExclude   结束位置（不包括）
+	 * @param moveLength   移动距离，负数表示左移，正数为右移
 	 * @return 位移后的字符串
 	 * @since 4.0.7
 	 */
@@ -4171,10 +4162,10 @@ public class StrUtil {
 
 	/**
 	 * 生成随机UUID
-	 * 
+	 *
 	 * @return UUID字符串
-	 * @since 4.0.10
 	 * @see IdUtil#randomUUID()
+	 * @since 4.0.10
 	 */
 	public static String uuid() {
 		return IdUtil.randomUUID();
@@ -4182,9 +4173,9 @@ public class StrUtil {
 
 	/**
 	 * 连接多个字符串为一个
-	 * 
+	 *
 	 * @param isNullToEmpty 是否null转为""
-	 * @param strs 字符串数组
+	 * @param strs          字符串数组
 	 * @return 连接后的字符串
 	 * @since 4.1.0
 	 */
@@ -4198,12 +4189,12 @@ public class StrUtil {
 
 	/**
 	 * 给定字符串中的字母是否全部为大写，判断依据如下：
-	 * 
+	 *
 	 * <pre>
 	 * 1. 大写字母包括A-Z
 	 * 2. 其它非字母的Unicode符都算作大写
 	 * </pre>
-	 * 
+	 *
 	 * @param str 被检查的字符串
 	 * @return 是否全部为大写
 	 * @since 4.2.2
@@ -4223,12 +4214,12 @@ public class StrUtil {
 
 	/**
 	 * 给定字符串中的字母是否全部为小写，判断依据如下：
-	 * 
+	 *
 	 * <pre>
 	 * 1. 小写字母包括a-z
 	 * 2. 其它非字母的Unicode符都算作小写
 	 * </pre>
-	 * 
+	 *
 	 * @param str 被检查的字符串
 	 * @return 是否全部为小写
 	 * @since 4.2.2
@@ -4256,11 +4247,11 @@ public class StrUtil {
 	public static int length(CharSequence cs) {
 		return cs == null ? 0 : cs.length();
 	}
-	
+
 	/**
 	 * 给定字符串转为bytes后的byte数（byte长度）
-	 * 
-	 * @param cs 字符串
+	 *
+	 * @param cs      字符串
 	 * @param charset 编码
 	 * @return byte长度
 	 * @since 4.5.2
diff --git a/hutool-core/src/test/java/cn/hutool/core/util/StrUtilTest.java b/hutool-core/src/test/java/cn/hutool/core/util/StrUtilTest.java
index f0fd31419..6e3a41fde 100644
--- a/hutool-core/src/test/java/cn/hutool/core/util/StrUtilTest.java
+++ b/hutool-core/src/test/java/cn/hutool/core/util/StrUtilTest.java
@@ -424,8 +424,8 @@ public class StrUtilTest {
 
 	@Test
 	public void subBetweenAllTest() {
-		Assert.assertArrayEquals(new String[]{"yz","abc"},StrUtil.subBetweenAll("saho[yz]fdsadp[abc]a","\\[","\\]"));
-		Assert.assertArrayEquals(new String[]{"abc"}, StrUtil.subBetweenAll("saho[yzfdsadp[abc]a]","\\[","\\]"));
+		Assert.assertArrayEquals(new String[]{"yz","abc"},StrUtil.subBetweenAll("saho[yz]fdsadp[abc]a","[","]"));
+		Assert.assertArrayEquals(new String[]{"abc"}, StrUtil.subBetweenAll("saho[yzfdsadp[abc]a]","[","]"));
 	}
 	
 }