zhouxy108/hutool
1
0
Fork 0
mirror of https://gitee.com/chinabugotech/hutool.git synced 2025-07-21 15:09:48 +08:00
Code Issues Packages Projects Releases Wiki Activity

add method

Browse Source
This commit is contained in:
Looly
2020-03-29 10:07:59 +08:00
parent 9ea0e983bd
commit bcd773b85a
3 changed files with 514 additions and 524 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
hutool-core/src/main/java/cn/hutool/core/lang/Console.java
View File

@@ -1,13 +1,12 @@
package cn.hutool.core.lang; 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.CharUtil;
import cn.hutool.core.util.StrUtil; import cn.hutool.core.util.StrUtil;
import java.util.Scanner;
import static java.lang.System.err; import static java.lang.System.err;
import static java.lang.System.out;
/** /**
* 命令行（控制台）工具方法类<br> * 命令行（控制台）工具方法类<br>
@@ -189,7 +188,7 @@ public class Console {
* @since 5.2.5 * @since 5.2.5
*/ */
public static String where() { public static String where() {
StackTraceElement stackTraceElement = new Throwable().getStackTrace()[1]; final StackTraceElement stackTraceElement = new Throwable().getStackTrace()[1];
final String className = stackTraceElement.getClassName(); final String className = stackTraceElement.getClassName();
final String methodName = stackTraceElement.getMethodName(); final String methodName = stackTraceElement.getMethodName();
final String fileName = stackTraceElement.getFileName(); final String fileName = stackTraceElement.getFileName();

105
hutool-core/src/main/java/cn/hutool/core/util/StrUtil.java
View File

@@ -1,14 +1,5 @@
package cn.hutool.core.util; 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.comparator.VersionComparator;
import cn.hutool.core.convert.Convert; import cn.hutool.core.convert.Convert;
import cn.hutool.core.lang.Assert; 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.StrSpliter;
import cn.hutool.core.text.TextSimilarity; 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 { public class StrUtil {
@@ -74,6 +78,7 @@ public class StrUtil {
public static final String EMPTY_JSON = "{}"; public static final String EMPTY_JSON = "{}";
// ------------------------------------------------------------------------ Blank // ------------------------------------------------------------------------ Blank
/** /**
* 字符串是否为空白 空白的定义如下： <br> * 字符串是否为空白 空白的定义如下： <br>
* 1、为null <br> * 1、为null <br>
@@ -171,6 +176,7 @@ public class StrUtil {
} }
// ------------------------------------------------------------------------ Empty // ------------------------------------------------------------------------ Empty
/** /**
* 字符串是否为空，空的定义如下:<br> * 字符串是否为空，空的定义如下:<br>
* 1、为null <br> * 1、为null <br>
@@ -218,8 +224,8 @@ public class StrUtil {
* *
* @param str 被检查的字符串 * @param str 被检查的字符串
* @return 原字符串或者空串 * @return 原字符串或者空串
* @since 4.6.3
* @see #nullToEmpty(CharSequence) * @see #nullToEmpty(CharSequence)
* @since 4.6.3
*/ */
public static String emptyIfNull(CharSequence str) { public static String emptyIfNull(CharSequence str) {
return nullToEmpty(str); return nullToEmpty(str);
@@ -247,7 +253,6 @@ public class StrUtil {
* *
* @param str 要转换的字符串 * @param str 要转换的字符串
* @param defaultStr 默认字符串 * @param defaultStr 默认字符串
*
* @return 字符串本身或指定的默认字符串 * @return 字符串本身或指定的默认字符串
*/ */
public static String nullToDefault(CharSequence str, String defaultStr) { public static String nullToDefault(CharSequence str, String defaultStr) {
@@ -266,7 +271,6 @@ public class StrUtil {
* *
* @param str 要转换的字符串 * @param str 要转换的字符串
* @param defaultStr 默认字符串 * @param defaultStr 默认字符串
*
* @return 字符串本身或指定的默认字符串 * @return 字符串本身或指定的默认字符串
* @since 4.1.0 * @since 4.1.0
*/ */
@@ -286,7 +290,6 @@ public class StrUtil {
* *
* @param str 要转换的字符串 * @param str 要转换的字符串
* @param defaultStr 默认字符串 * @param defaultStr 默认字符串
*
* @return 字符串本身或指定的默认字符串 * @return 字符串本身或指定的默认字符串
* @since 4.1.0 * @since 4.1.0
*/ */
@@ -396,6 +399,7 @@ public class StrUtil {
} }
// ------------------------------------------------------------------------ Trim // ------------------------------------------------------------------------ Trim
/** /**
* 除去字符串头尾部的空白，如果字符串是<code>null</code>，依然返回<code>null</code>。 * 除去字符串头尾部的空白，如果字符串是<code>null</code>，依然返回<code>null</code>。
* *
@@ -411,7 +415,6 @@ public class StrUtil {
* </pre> * </pre>
* *
* @param str 要处理的字符串 * @param str 要处理的字符串
*
* @return 除去头尾空白的字符串，如果原字串为<code>null</code>，则返回<code>null</code> * @return 除去头尾空白的字符串，如果原字串为<code>null</code>，则返回<code>null</code>
*/ */
public static String trim(CharSequence str) { public static String trim(CharSequence str) {
@@ -491,7 +494,6 @@ public class StrUtil {
* </pre> * </pre>
* *
* @param str 要处理的字符串 * @param str 要处理的字符串
*
* @return 除去空白的字符串，如果原字串为<code>null</code>或结果字符串为<code>""</code>，则返回 <code>null</code> * @return 除去空白的字符串，如果原字串为<code>null</code>或结果字符串为<code>""</code>，则返回 <code>null</code>
*/ */
public static String trimStart(CharSequence str) { public static String trimStart(CharSequence str) {
@@ -514,7 +516,6 @@ public class StrUtil {
* </pre> * </pre>
* *
* @param str 要处理的字符串 * @param str 要处理的字符串
*
* @return 除去空白的字符串，如果原字串为<code>null</code>或结果字符串为<code>""</code>，则返回 <code>null</code> * @return 除去空白的字符串，如果原字串为<code>null</code>或结果字符串为<code>""</code>，则返回 <code>null</code>
*/ */
public static String trimEnd(CharSequence str) { public static String trimEnd(CharSequence str) {
@@ -526,7 +527,6 @@ public class StrUtil {
* *
* @param str 要处理的字符串 * @param str 要处理的字符串
* @param mode <code>-1</code>表示trimStart，<code>0</code>表示trim全部， <code>1</code>表示trimEnd * @param mode <code>-1</code>表示trimStart，<code>0</code>表示trim全部， <code>1</code>表示trimEnd
*
* @return 除去指定字符后的的字符串，如果原字串为<code>null</code>，则返回<code>null</code> * @return 除去指定字符后的的字符串，如果原字串为<code>null</code>，则返回<code>null</code>
*/ */
public static String trim(CharSequence str, int mode) { public static String trim(CharSequence str, int mode) {
@@ -732,7 +732,7 @@ public class StrUtil {
* @since 5.1.1 * @since 5.1.1
*/ */
public static boolean contains(CharSequence str, CharSequence searchStr) { public static boolean contains(CharSequence str, CharSequence searchStr) {
if(null == str || null == searchStr){ if (null == str || null == searchStr) {
return false; return false;
} }
return str.toString().contains(searchStr); return str.toString().contains(searchStr);
@@ -901,7 +901,7 @@ public class StrUtil {
final String getOrSetMethodNameStr = getOrSetMethodName.toString(); final String getOrSetMethodNameStr = getOrSetMethodName.toString();
if (getOrSetMethodNameStr.startsWith("get") || getOrSetMethodNameStr.startsWith("set")) { if (getOrSetMethodNameStr.startsWith("get") || getOrSetMethodNameStr.startsWith("set")) {
return removePreAndLowerFirst(getOrSetMethodName, 3); return removePreAndLowerFirst(getOrSetMethodName, 3);
} else if(getOrSetMethodNameStr.startsWith("is")) { } else if (getOrSetMethodNameStr.startsWith("is")) {
return removePreAndLowerFirst(getOrSetMethodName, 2); return removePreAndLowerFirst(getOrSetMethodName, 2);
} }
return null; return null;
@@ -1308,6 +1308,7 @@ public class StrUtil {
} }
// ------------------------------------------------------------------------------ Split // ------------------------------------------------------------------------------ Split
/** /**
* 切分字符串 * 切分字符串
* *
@@ -1390,7 +1391,7 @@ public class StrUtil {
*/ */
public static String[] splitToArray(CharSequence str, char separator, int limit) { public static String[] splitToArray(CharSequence str, char separator, int limit) {
if (null == str) { if (null == str) {
return new String[] {}; return new String[]{};
} }
return StrSpliter.splitToArray(str.toString(), separator, limit, false, false); return StrSpliter.splitToArray(str.toString(), separator, limit, false, false);
} }
@@ -1517,7 +1518,7 @@ public class StrUtil {
*/ */
public static String[] split(CharSequence str, CharSequence separator) { public static String[] split(CharSequence str, CharSequence separator) {
if (str == null) { if (str == null) {
return new String[] {}; return new String[]{};
} }
final String separatorStr = (null == separator) ? null : separator.toString(); final String separatorStr = (null == separator) ? null : separator.toString();
@@ -1534,7 +1535,7 @@ public class StrUtil {
*/ */
public static String[] split(CharSequence str, int len) { public static String[] split(CharSequence str, int len) {
if (null == str) { if (null == str) {
return new String[] {}; return new String[]{};
} }
return StrSpliter.splitByLength(str.toString(), len); return StrSpliter.splitByLength(str.toString(), len);
} }
@@ -1884,7 +1885,7 @@ public class StrUtil {
/** /**
* 截取指定字符串中间部分，不包括标识字符串<br> * 截取指定字符串中间部分，不包括标识字符串<br>
* * <p>
* 栗子： * 栗子：
* *
* <pre> * <pre>
@@ -1927,7 +1928,7 @@ public class StrUtil {
/** /**
* 截取指定字符串中间部分，不包括标识字符串<br> * 截取指定字符串中间部分，不包括标识字符串<br>
* * <p>
* 栗子： * 栗子：
* *
* <pre> * <pre>
@@ -1950,7 +1951,7 @@ public class StrUtil {
/** /**
* 截取指定字符串多段中间部分，不包括标识字符串<br> * 截取指定字符串多段中间部分，不包括标识字符串<br>
* * <p>
* 栗子： * 栗子：
* *
* <pre> * <pre>
@@ -1968,45 +1969,43 @@ public class StrUtil {
* </pre> * </pre>
* *
* @param str 被切割的字符串 * @param str 被切割的字符串
* @param regexBefore 截取开始的字符串标识 * @param prefix 截取开始的字符串标识
* @param regexAfter 截取到的字符串标识 * @param suffix 截取到的字符串标识
* @return 截取后的字符串 * @return 截取后的字符串
* @author dahuoyzs * @author dahuoyzs
* @since 5.2.5 * @since 5.2.5
*/ */
public static String[] subBetweenAll(CharSequence str, CharSequence regexBefore, CharSequence regexAfter) { public static String[] subBetweenAll(CharSequence str, CharSequence prefix, CharSequence suffix) {
if (str == null || regexBefore == null || regexAfter == null || str.length() < 1 || regexBefore.length() < 1 || regexAfter.length() < 1) { if(hasEmpty(str, prefix, suffix)) {
return new String[0]; return new String[0];
} }
final String before = regexBefore.toString().replace("\\", ""); final int prefixCount = count(str, prefix);
final String after = regexAfter.toString().replace("\\", ""); final int suffixCount = count(str, suffix);
final Integer beforeNumber = StrUtil.count(str, before); if (prefixCount < 1 || suffixCount < 1) {
final Integer afterNumber = StrUtil.count(str, after);
if (beforeNumber<1||afterNumber<1){
return new String[0]; return new String[0];
} }
LinkedList<String> betweenList = new LinkedList<>(); LinkedList<String> betweenList = new LinkedList<>();
if (beforeNumber.compareTo(afterNumber) > 0) { if (prefixCount > suffixCount) {
String[] fragments = str.toString().split(regexAfter.toString()); String[] fragments = split(str, suffix);
for (int i = 0; i < fragments.length - 1; i++) { for (int i = 0; i < fragments.length - 1; i++) {
String fragment = fragments[i]; String fragment = fragments[i];
if (fragment.contains(before)) { if (fragment.contains(prefix)) {
int beforeIndex = StrUtil.lastIndexOf(fragment, before, 0, false); int beforeIndex = StrUtil.lastIndexOf(fragment, prefix, 0, false);
String between = fragment.substring(beforeIndex); String between = fragment.substring(beforeIndex);
if (between.length()>0) if (between.length() > 0)
betweenList.add(between); betweenList.add(between);
} }
} }
} else { } else {
String[] fragments = str.toString().split(regexBefore.toString()); String[] fragments = split(str, prefix);
for (int i = 1; i < fragments.length; i++) { for (int i = 1; i < fragments.length; i++) {
String fragment = fragments[i]; String fragment = fragments[i];
if (fragment.contains(after)) { if (fragment.contains(suffix)) {
int afterIndex = StrUtil.indexOf(fragment, after, 0, false); int afterIndex = StrUtil.indexOf(fragment, suffix, 0, false);
String between = fragment.substring(0, afterIndex); String between = fragment.substring(0, afterIndex);
if (between.length()>0) if (between.length() > 0)
betweenList.add(between); betweenList.add(between);
} }
} }
@@ -2184,7 +2183,6 @@ public class StrUtil {
* *
* @param str1 要比较的字符串1 * @param str1 要比较的字符串1
* @param str2 要比较的字符串2 * @param str2 要比较的字符串2
*
* @return 如果两个字符串相同，或者都是<code>null</code>，则返回<code>true</code> * @return 如果两个字符串相同，或者都是<code>null</code>，则返回<code>true</code>
*/ */
public static boolean equals(CharSequence str1, CharSequence str2) { public static boolean equals(CharSequence str1, CharSequence str2) {
@@ -2204,7 +2202,6 @@ public class StrUtil {
* *
* @param str1 要比较的字符串1 * @param str1 要比较的字符串1
* @param str2 要比较的字符串2 * @param str2 要比较的字符串2
*
* @return 如果两个字符串相同，或者都是<code>null</code>，则返回<code>true</code> * @return 如果两个字符串相同，或者都是<code>null</code>，则返回<code>true</code>
*/ */
public static boolean equalsIgnoreCase(CharSequence str1, CharSequence str2) { public static boolean equalsIgnoreCase(CharSequence str1, CharSequence str2) {
@@ -2576,11 +2573,10 @@ public class StrUtil {
/** /**
* 以 conjunction 为分隔符将多个对象转换为字符串 * 以 conjunction 为分隔符将多个对象转换为字符串
* *
* @see ArrayUtil#join(Object, CharSequence)
*
* @param conjunction 分隔符 * @param conjunction 分隔符
* @param objs 数组 * @param objs 数组
* @return 连接后的字符串 * @return 连接后的字符串
* @see ArrayUtil#join(Object, CharSequence)
*/ */
public static String join(CharSequence conjunction, Object... objs) { public static String join(CharSequence conjunction, Object... objs) {
return ArrayUtil.join(objs, conjunction); return ArrayUtil.join(objs, conjunction);
@@ -3265,7 +3261,7 @@ public class StrUtil {
} }
int len = str.length(); int len = str.length();
if (len < partLength) { if (len < partLength) {
return new String[] { str.toString() }; return new String[]{str.toString()};
} }
int part = NumberUtil.count(len, partLength); int part = NumberUtil.count(len, partLength);
final String[] array = new String[part]; final String[] array = new String[part];
@@ -3605,7 +3601,7 @@ public class StrUtil {
* <p> * <p>
* 如果 str=null 或 searchStr=null 或 ordinal&ge;0 则返回-1<br> * 如果 str=null 或 searchStr=null 或 ordinal&ge;0 则返回-1<br>
* 此方法来自：Apache-Commons-Lang * 此方法来自：Apache-Commons-Lang
* * <p>
* 例子（*代表任意字符）： * 例子（*代表任意字符）：
* *
* <pre> * <pre>
@@ -3648,6 +3644,7 @@ public class StrUtil {
} }
// ------------------------------------------------------------------------------------------------------------------ Append and prepend // ------------------------------------------------------------------------------------------------------------------ Append and prepend
/** /**
* 如果给定字符串不是以给定的一个或多个字符串为结尾，则在尾部添加结尾字符串<br> * 如果给定字符串不是以给定的一个或多个字符串为结尾，则在尾部添加结尾字符串<br>
* 不忽略大小写 * 不忽略大小写
@@ -3655,7 +3652,6 @@ public class StrUtil {
* @param str 被检查的字符串 * @param str 被检查的字符串
* @param suffix 需要添加到结尾的字符串 * @param suffix 需要添加到结尾的字符串
* @param suffixes 需要额外检查的结尾字符串，如果以这些中的一个为结尾，则不再添加 * @param suffixes 需要额外检查的结尾字符串，如果以这些中的一个为结尾，则不再添加
*
* @return 如果已经结尾，返回原字符串，否则返回添加结尾的字符串 * @return 如果已经结尾，返回原字符串，否则返回添加结尾的字符串
* @since 3.0.7 * @since 3.0.7
*/ */
@@ -3670,7 +3666,6 @@ public class StrUtil {
* @param str 被检查的字符串 * @param str 被检查的字符串
* @param suffix 需要添加到结尾的字符串 * @param suffix 需要添加到结尾的字符串
* @param suffixes 需要额外检查的结尾字符串，如果以这些中的一个为结尾，则不再添加 * @param suffixes 需要额外检查的结尾字符串，如果以这些中的一个为结尾，则不再添加
*
* @return 如果已经结尾，返回原字符串，否则返回添加结尾的字符串 * @return 如果已经结尾，返回原字符串，否则返回添加结尾的字符串
* @since 3.0.7 * @since 3.0.7
*/ */
@@ -3685,7 +3680,6 @@ public class StrUtil {
* @param suffix 需要添加到结尾的字符串 * @param suffix 需要添加到结尾的字符串
* @param ignoreCase 检查结尾时是否忽略大小写 * @param ignoreCase 检查结尾时是否忽略大小写
* @param suffixes 需要额外检查的结尾字符串，如果以这些中的一个为结尾，则不再添加 * @param suffixes 需要额外检查的结尾字符串，如果以这些中的一个为结尾，则不再添加
*
* @return 如果已经结尾，返回原字符串，否则返回添加结尾的字符串 * @return 如果已经结尾，返回原字符串，否则返回添加结尾的字符串
* @since 3.0.7 * @since 3.0.7
*/ */
@@ -3710,7 +3704,6 @@ public class StrUtil {
* @param str 被检查的字符串 * @param str 被检查的字符串
* @param prefix 需要添加到首部的字符串 * @param prefix 需要添加到首部的字符串
* @param prefixes 需要额外检查的首部字符串，如果以这些中的一个为起始，则不再添加 * @param prefixes 需要额外检查的首部字符串，如果以这些中的一个为起始，则不再添加
*
* @return 如果已经结尾，返回原字符串，否则返回添加结尾的字符串 * @return 如果已经结尾，返回原字符串，否则返回添加结尾的字符串
* @since 3.0.7 * @since 3.0.7
*/ */
@@ -3725,7 +3718,6 @@ public class StrUtil {
* @param str 被检查的字符串 * @param str 被检查的字符串
* @param prefix 需要添加到首部的字符串 * @param prefix 需要添加到首部的字符串
* @param prefixes 需要额外检查的首部字符串，如果以这些中的一个为起始，则不再添加 * @param prefixes 需要额外检查的首部字符串，如果以这些中的一个为起始，则不再添加
*
* @return 如果已经结尾，返回原字符串，否则返回添加结尾的字符串 * @return 如果已经结尾，返回原字符串，否则返回添加结尾的字符串
* @since 3.0.7 * @since 3.0.7
*/ */
@@ -3740,7 +3732,6 @@ public class StrUtil {
* @param prefix 需要添加到首部的字符串 * @param prefix 需要添加到首部的字符串
* @param ignoreCase 检查结尾时是否忽略大小写 * @param ignoreCase 检查结尾时是否忽略大小写
* @param prefixes 需要额外检查的首部字符串，如果以这些中的一个为起始，则不再添加 * @param prefixes 需要额外检查的首部字符串，如果以这些中的一个为起始，则不再添加
*
* @return 如果已经结尾，返回原字符串，否则返回添加结尾的字符串 * @return 如果已经结尾，返回原字符串，否则返回添加结尾的字符串
* @since 3.0.7 * @since 3.0.7
*/ */
@@ -4173,8 +4164,8 @@ public class StrUtil {
* 生成随机UUID * 生成随机UUID
* *
* @return UUID字符串 * @return UUID字符串
* @since 4.0.10
* @see IdUtil#randomUUID() * @see IdUtil#randomUUID()
* @since 4.0.10
*/ */
public static String uuid() { public static String uuid() {
return IdUtil.randomUUID(); return IdUtil.randomUUID();

4
hutool-core/src/test/java/cn/hutool/core/util/StrUtilTest.java
View File

@@ -424,8 +424,8 @@ public class StrUtilTest {
@Test @Test
public void subBetweenAllTest() { public void subBetweenAllTest() {
Assert.assertArrayEquals(new String[]{"yz","abc"},StrUtil.subBetweenAll("saho[yz]fdsadp[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]","\\[","\\]")); Assert.assertArrayEquals(new String[]{"abc"}, StrUtil.subBetweenAll("saho[yzfdsadp[abc]a]","[","]"));
} }
} }