public class StringUtil extends Object
null,而不会抛出NullPointerException。| 限定符和类型 | 字段和说明 |
|---|---|
static String |
EMPTY_STRING
空字符串。
|
| 构造器和说明 |
|---|
StringUtil() |
| 限定符和类型 | 方法和说明 |
|---|---|
static String |
abbreviate(String str,
int maxWidth)
将字符串转换成指定长度的缩略,例如: 将"Now is the time for all good men"转换成"Now is the time for..."。
|
static String |
abbreviate(String str,
int offset,
int maxWidth)
将字符串转换成指定长度的缩略,例如: 将"Now is the time for all good men"转换成"...is the time for..."。
|
static String |
alignLeft(String str,
int size)
扩展并左对齐字符串,用空格
' '填充右边。 |
static String |
alignLeft(String str,
int size,
char padChar)
扩展并左对齐字符串,用指定字符填充右边。
|
static String |
alignLeft(String str,
int size,
String padStr)
扩展并左对齐字符串,用指定字符串填充右边。
|
static String |
alignRight(String str,
int size)
扩展并右对齐字符串,用空格
' '填充左边。 |
static String |
alignRight(String str,
int size,
char padChar)
扩展并右对齐字符串,用指定字符填充左边。
|
static String |
alignRight(String str,
int size,
String padStr)
扩展并右对齐字符串,用指定字符串填充左边。
|
static String |
capitalize(String str)
将字符串的首字符转成大写(
Character.toTitleCase),其它字符不变。 |
static String |
center(String str,
int size)
扩展并居中字符串,用空格
' '填充两边。 |
static String |
center(String str,
int size,
char padChar)
扩展并居中字符串,用指定字符填充两边。
|
static String |
center(String str,
int size,
String padStr)
扩展并居中字符串,用指定字符串填充两边。
|
static String |
chomp(String str)
删除字符串末尾的换行符。
|
static String |
chomp(String str,
String separator)
删除字符串末尾的指定字符串。
|
static String |
chop(String str)
删除最后一个字符。
|
static boolean |
contains(String str,
char searchChar)
检查字符串中是否包含指定的字符。
|
static boolean |
contains(String str,
String searchStr)
检查字符串中是否包含指定的字符串。
|
static boolean |
containsNone(String str,
char[] invalid)
检查字符串是是否不包含指定字符集合中的字符。
|
static boolean |
containsNone(String str,
String invalidChars)
检查字符串是是否不包含指定字符集合中的字符。
|
static boolean |
containsOnly(String str,
char[] valid)
检查字符串是是否只包含指定字符集合中的字符。
|
static boolean |
containsOnly(String str,
String valid)
检查字符串是是否只包含指定字符集合中的字符。
|
static int |
countMatches(String str,
String subStr)
取得指定子串在字符串中出现的次数。
|
static String |
defaultIfBlank(String str)
如果字符串是空白:
null、空字符串""或只有空白字符,则返回空字符串"",否则返回字符串本身。 |
static String |
defaultIfBlank(String str,
String defaultStr)
如果字符串是
null或空字符串"",则返回指定默认字符串,否则返回字符串本身。 |
static String |
defaultIfEmpty(String str)
如果字符串是
null或空字符串"",则返回空字符串"",否则返回字符串本身。 |
static String |
defaultIfEmpty(String str,
String defaultStr)
如果字符串是
null或空字符串"",则返回指定默认字符串,否则返回字符串本身。 |
static String |
defaultIfNull(String str)
如果字符串是
null,则返回空字符串"",否则返回字符串本身。 |
static String |
defaultIfNull(String str,
String defaultStr)
如果字符串是
null,则返回指定默认字符串,否则返回字符串本身。 |
static String |
deleteWhitespace(String str)
删除所有在
Character.isWhitespace(char)中所定义的空白。 |
static String |
difference(String str1,
String str2)
比较两个字符串,取得第二个字符串中,和第一个字符串不同的部分。
|
static boolean |
equals(String str1,
String str2)
比较两个字符串(大小写敏感)。
|
static boolean |
equalsIgnoreCase(String str1,
String str2)
比较两个字符串(大小写不敏感)。
|
static int |
getLevenshteinDistance(String s,
String t)
取得两个字符串的相似度,
0代表字符串相等,数字越大表示字符串越不像。 |
static int |
indexOf(String str,
char searchChar)
在字符串中查找指定字符,并返回第一个匹配的索引值。
|
static int |
indexOf(String str,
char searchChar,
int startPos)
在字符串中查找指定字符,并返回第一个匹配的索引值。
|
static int |
indexOf(String str,
String searchStr)
在字符串中查找指定字符串,并返回第一个匹配的索引值。
|
static int |
indexOf(String str,
String searchStr,
int startPos)
在字符串中查找指定字符串,并返回第一个匹配的索引值。
|
static int |
indexOfAny(String str,
char[] searchChars)
在字符串中查找指定字符集合中的字符,并返回第一个匹配的起始索引。
|
static int |
indexOfAny(String str,
String searchChars)
在字符串中查找指定字符集合中的字符,并返回第一个匹配的起始索引。
|
static int |
indexOfAny(String str,
String[] searchStrs)
在字符串中查找指定字符串集合中的字符串,并返回第一个匹配的起始索引。
|
static int |
indexOfAnyBut(String str,
char[] searchChars)
在字符串中查找不在指定字符集合中的字符,并返回第一个匹配的起始索引。
|
static int |
indexOfAnyBut(String str,
String searchChars)
在字符串中查找不在指定字符集合中的字符,并返回第一个匹配的起始索引。
|
static int |
indexOfDifference(String str1,
String str2)
比较两个字符串,取得两字符串开始不同的索引值。
|
static boolean |
isAlpha(String str)
判断字符串是否只包含unicode字母。
|
static boolean |
isAlphanumeric(String str)
判断字符串是否只包含unicode字母和数字。
|
static boolean |
isAlphanumericSpace(String str)
判断字符串是否只包含unicode字母数字和空格
' '。 |
static boolean |
isAlphaSpace(String str)
判断字符串是否只包含unicode字母和空格
' '。 |
static boolean |
isBlank(String str)
检查字符串是否是空白:
null、空字符串""或只有空白字符。 |
static boolean |
isEmpty(String str)
检查字符串是否为
null或空字符串""。 |
static boolean |
isNotBlank(String str)
检查字符串是否不是空白:
null、空字符串""或只有空白字符。 |
static boolean |
isNotEmpty(String str)
检查字符串是否不是
null和空字符串""。 |
static boolean |
isNumeric(String str)
判断字符串是否只包含unicode数字。
|
static boolean |
isNumericSpace(String str)
判断字符串是否只包含unicode数字和空格
' '。 |
static boolean |
isWhitespace(String str)
判断字符串是否只包含unicode空白。
|
static String |
join(Iterator iterator,
char separator)
将
Iterator中的元素连接成一个字符串。 |
static String |
join(Iterator iterator,
String separator)
将
Iterator中的元素连接成一个字符串。 |
static String |
join(Object[] array)
将数组中的元素连接成一个字符串。
|
static String |
join(Object[] array,
char separator)
将数组中的元素连接成一个字符串。
|
static String |
join(Object[] array,
String separator)
将数组中的元素连接成一个字符串。
|
static int |
lastIndexOf(String str,
char searchChar)
从字符串尾部开始查找指定字符,并返回第一个匹配的索引值。
|
static int |
lastIndexOf(String str,
char searchChar,
int startPos)
从字符串尾部开始查找指定字符,并返回第一个匹配的索引值。
|
static int |
lastIndexOf(String str,
String searchStr)
从字符串尾部开始查找指定字符串,并返回第一个匹配的索引值。
|
static int |
lastIndexOf(String str,
String searchStr,
int startPos)
从字符串尾部开始查找指定字符串,并返回第一个匹配的索引值。
|
static int |
lastIndexOfAny(String str,
String[] searchStrs)
从字符串尾部开始查找指定字符串集合中的字符串,并返回第一个匹配的起始索引。
|
static String |
left(String str,
int len)
取得长度为指定字符数的最左边的子串。
|
static String |
mid(String str,
int pos,
int len)
取得从指定索引开始计算的、长度为指定字符数的子串。
|
static String |
overlay(String str,
String overlay,
int start,
int end)
将指定的子串用另一指定子串覆盖。
|
static String |
repeat(String str,
int repeat)
将指定字符串重复n遍。
|
static String |
replace(String text,
String repl,
String with)
替换指定的子串,替换所有出现的子串。
|
static String |
replace(String text,
String repl,
String with,
int max)
替换指定的子串,替换指定的次数。
|
static String |
replaceChars(String str,
char searchChar,
char replaceChar)
将字符串中所有指定的字符,替换成另一个。
|
static String |
replaceChars(String str,
String searchChars,
String replaceChars)
将字符串中所有指定的字符,替换成另一个。
|
static String |
replaceOnce(String text,
String repl,
String with)
替换指定的子串,只替换第一个出现的子串。
|
static String |
reverse(String str)
反转字符串中的字符顺序。
|
static String |
reverseDelimited(String str,
char separatorChar)
反转指定分隔符分隔的各子串的顺序。
|
static String |
reverseDelimited(String str,
String separatorChars,
String separator)
反转指定分隔符分隔的各子串的顺序。
|
static String |
right(String str,
int len)
取得长度为指定字符数的最右边的子串。
|
static String[] |
split(String str)
将字符串按空白字符分割。
|
static String[] |
split(String str,
char separatorChar)
将字符串按指定字符分割。
|
static String[] |
split(String str,
String separatorChars)
将字符串按指定字符分割。
|
static String[] |
split(String str,
String separatorChars,
int max)
将字符串按指定字符分割。
|
static String |
substring(String str,
int start)
取指定字符串的子串。
|
static String |
substring(String str,
int start,
int end)
取指定字符串的子串。
|
static String |
substringAfter(String str,
String separator)
取得第一个出现的分隔子串之后的子串。
|
static String |
substringAfterLast(String str,
String separator)
取得最后一个的分隔子串之后的子串。
|
static String |
substringBefore(String str,
String separator)
取得第一个出现的分隔子串之前的子串。
|
static String |
substringBeforeLast(String str,
String separator)
取得最后一个的分隔子串之前的子串。
|
static String |
substringBetween(String str,
String tag)
取得指定分隔符的前两次出现之间的子串。
|
static String |
substringBetween(String str,
String open,
String close)
取得两个分隔符之间的子串。
|
static String |
substringBetween(String str,
String open,
String close,
int fromIndex)
取得两个分隔符之间的子串。
|
static String |
swapCase(String str)
反转字符串的大小写。
|
static String |
toCamelCase(String str)
将字符串转换成camel case。
|
static String |
toLowerCase(String str)
将字符串转换成小写。
|
static String |
toLowerCaseWithUnderscores(String str)
将字符串转换成下划线分隔的小写字符串。
|
static String |
toPascalCase(String str)
将字符串转换成pascal case。
|
static String |
toUpperCase(String str)
将字符串转换成大写。
|
static String |
toUpperCaseWithUnderscores(String str)
将字符串转换成下划线分隔的大写字符串。
|
static String |
trim(String str)
除去字符串头尾部的空白,如果字符串是
null,依然返回null。 |
static String |
trim(String str,
String stripChars)
除去字符串头尾部的指定字符,如果字符串是
null,依然返回null。 |
static String |
trimEnd(String str)
除去字符串尾部的空白,如果字符串是
null,则返回null。 |
static String |
trimEnd(String str,
String stripChars)
除去字符串尾部的指定字符,如果字符串是
null,依然返回null。 |
static String |
trimStart(String str)
除去字符串头部的空白,如果字符串是
null,则返回null。 |
static String |
trimStart(String str,
String stripChars)
除去字符串头部的指定字符,如果字符串是
null,依然返回null。 |
static String |
trimToEmpty(String str)
除去字符串头尾部的空白,如果字符串是
null,则返回空字符串""。 |
static String |
trimToEmpty(String str,
String stripChars)
除去字符串头尾部的空白,如果字符串是
null,则返回空字符串""。 |
static String |
trimToNull(String str)
除去字符串头尾部的空白,如果结果字符串是空字符串
"",则返回null。 |
static String |
trimToNull(String str,
String stripChars)
除去字符串头尾部的空白,如果结果字符串是空字符串
"",则返回null。 |
static String |
uncapitalize(String str)
将字符串的首字符转成小写,其它字符不变。
|
public static boolean isEmpty(String str)
null或空字符串""。
StringUtil.isEmpty(null) = true
StringUtil.isEmpty("") = true
StringUtil.isEmpty(" ") = false
StringUtil.isEmpty("bob") = false
StringUtil.isEmpty(" bob ") = false
str 要检查的字符串
如果为空, 则返回truepublic static boolean isNotEmpty(String str)
null和空字符串""。
StringUtil.isEmpty(null) = false
StringUtil.isEmpty("") = false
StringUtil.isEmpty(" ") = true
StringUtil.isEmpty("bob") = true
StringUtil.isEmpty(" bob ") = true
str 要检查的字符串
如果不为空, 则返回truepublic static boolean isBlank(String str)
null、空字符串""或只有空白字符。
StringUtil.isBlank(null) = true
StringUtil.isBlank("") = true
StringUtil.isBlank(" ") = true
StringUtil.isBlank("bob") = false
StringUtil.isBlank(" bob ") = false
str 要检查的字符串
如果为空白, 则返回truepublic static boolean isNotBlank(String str)
null、空字符串""或只有空白字符。
StringUtil.isBlank(null) = false
StringUtil.isBlank("") = false
StringUtil.isBlank(" ") = false
StringUtil.isBlank("bob") = true
StringUtil.isBlank(" bob ") = true
str 要检查的字符串
如果为空白, 则返回truepublic static String defaultIfNull(String str)
null,则返回空字符串"",否则返回字符串本身。
StringUtil.defaultIfNull(null) = ""
StringUtil.defaultIfNull("") = ""
StringUtil.defaultIfNull(" ") = " "
StringUtil.defaultIfNull("bat") = "bat"
str 要转换的字符串
字符串本身或空字符串""public static String defaultIfNull(String str, String defaultStr)
null,则返回指定默认字符串,否则返回字符串本身。
StringUtil.defaultIfNull(null, "default") = "default"
StringUtil.defaultIfNull("", "default") = ""
StringUtil.defaultIfNull(" ", "default") = " "
StringUtil.defaultIfNull("bat", "default") = "bat"
str 要转换的字符串
defaultStr 默认字符串
字符串本身或指定的默认字符串public static String defaultIfEmpty(String str)
null或空字符串"",则返回空字符串"",否则返回字符串本身。
此方法实际上和defaultIfNull(String)等效。
StringUtil.defaultIfEmpty(null) = ""
StringUtil.defaultIfEmpty("") = ""
StringUtil.defaultIfEmpty(" ") = " "
StringUtil.defaultIfEmpty("bat") = "bat"
str 要转换的字符串
字符串本身或空字符串""public static String defaultIfEmpty(String str, String defaultStr)
null或空字符串"",则返回指定默认字符串,否则返回字符串本身。
StringUtil.defaultIfEmpty(null, "default") = "default"
StringUtil.defaultIfEmpty("", "default") = "default"
StringUtil.defaultIfEmpty(" ", "default") = " "
StringUtil.defaultIfEmpty("bat", "default") = "bat"
str 要转换的字符串
defaultStr 默认字符串
字符串本身或指定的默认字符串public static String defaultIfBlank(String str)
null、空字符串""或只有空白字符,则返回空字符串"",否则返回字符串本身。
StringUtil.defaultIfBlank(null) = ""
StringUtil.defaultIfBlank("") = ""
StringUtil.defaultIfBlank(" ") = ""
StringUtil.defaultIfBlank("bat") = "bat"
str 要转换的字符串
字符串本身或空字符串""public static String defaultIfBlank(String str, String defaultStr)
null或空字符串"",则返回指定默认字符串,否则返回字符串本身。
StringUtil.defaultIfBlank(null, "default") = "default"
StringUtil.defaultIfBlank("", "default") = "default"
StringUtil.defaultIfBlank(" ", "default") = "default"
StringUtil.defaultIfBlank("bat", "default") = "bat"
str 要转换的字符串
defaultStr 默认字符串
字符串本身或指定的默认字符串public static String trim(String str)
null,依然返回null。
注意,和String.trim不同,此方法使用Character.isWhitespace来判定空白,
因而可以除去英文字符集之外的其它空白,如中文空格。
StringUtil.trim(null) = null
StringUtil.trim("") = ""
StringUtil.trim(" ") = ""
StringUtil.trim("abc") = "abc"
StringUtil.trim(" abc ") = "abc"
str 要处理的字符串
除去空白的字符串,如果原字串为null,则返回nullpublic static String trim(String str, String stripChars)
null,依然返回null。
StringUtil.trim(null, *) = null
StringUtil.trim("", *) = ""
StringUtil.trim("abc", null) = "abc"
StringUtil.trim(" abc", null) = "abc"
StringUtil.trim("abc ", null) = "abc"
StringUtil.trim(" abc ", null) = "abc"
StringUtil.trim(" abcyx", "xyz") = " abc"
str 要处理的字符串
stripChars 要除去的字符,如果为null表示除去空白字符
除去指定字符后的的字符串,如果原字串为null,则返回nullpublic static String trimStart(String str)
null,则返回null。
注意,和String.trim不同,此方法使用Character.isWhitespace来判定空白,
因而可以除去英文字符集之外的其它空白,如中文空格。
StringUtil.trimStart(null) = null
StringUtil.trimStart("") = ""
StringUtil.trimStart("abc") = "abc"
StringUtil.trimStart(" abc") = "abc"
StringUtil.trimStart("abc ") = "abc "
StringUtil.trimStart(" abc ") = "abc "
str 要处理的字符串
除去空白的字符串,如果原字串为null或结果字符串为"",则返回nullpublic static String trimStart(String str, String stripChars)
null,依然返回null。
StringUtil.trimStart(null, *) = null
StringUtil.trimStart("", *) = ""
StringUtil.trimStart("abc", "") = "abc"
StringUtil.trimStart("abc", null) = "abc"
StringUtil.trimStart(" abc", null) = "abc"
StringUtil.trimStart("abc ", null) = "abc "
StringUtil.trimStart(" abc ", null) = "abc "
StringUtil.trimStart("yxabc ", "xyz") = "abc "
str 要处理的字符串
stripChars 要除去的字符,如果为null表示除去空白字符
除去指定字符后的的字符串,如果原字串为null,则返回nullpublic static String trimEnd(String str)
null,则返回null。
注意,和String.trim不同,此方法使用Character.isWhitespace来判定空白,
因而可以除去英文字符集之外的其它空白,如中文空格。
StringUtil.trimEnd(null) = null
StringUtil.trimEnd("") = ""
StringUtil.trimEnd("abc") = "abc"
StringUtil.trimEnd(" abc") = " abc"
StringUtil.trimEnd("abc ") = "abc"
StringUtil.trimEnd(" abc ") = " abc"
str 要处理的字符串
除去空白的字符串,如果原字串为null或结果字符串为"",则返回nullpublic static String trimEnd(String str, String stripChars)
null,依然返回null。
StringUtil.trimEnd(null, *) = null
StringUtil.trimEnd("", *) = ""
StringUtil.trimEnd("abc", "") = "abc"
StringUtil.trimEnd("abc", null) = "abc"
StringUtil.trimEnd(" abc", null) = " abc"
StringUtil.trimEnd("abc ", null) = "abc"
StringUtil.trimEnd(" abc ", null) = " abc"
StringUtil.trimEnd(" abcyx", "xyz") = " abc"
str 要处理的字符串
stripChars 要除去的字符,如果为null表示除去空白字符
除去指定字符后的的字符串,如果原字串为null,则返回nullpublic static String trimToNull(String str)
"",则返回null。
注意,和String.trim不同,此方法使用Character.isWhitespace来判定空白,
因而可以除去英文字符集之外的其它空白,如中文空格。
StringUtil.trimToNull(null) = null
StringUtil.trimToNull("") = null
StringUtil.trimToNull(" ") = null
StringUtil.trimToNull("abc") = "abc"
StringUtil.trimToNull(" abc ") = "abc"
str 要处理的字符串
除去空白的字符串,如果原字串为null或结果字符串为"",则返回nullpublic static String trimToNull(String str, String stripChars)
"",则返回null。
注意,和String.trim不同,此方法使用Character.isWhitespace来判定空白,
因而可以除去英文字符集之外的其它空白,如中文空格。
StringUtil.trim(null, *) = null
StringUtil.trim("", *) = null
StringUtil.trim("abc", null) = "abc"
StringUtil.trim(" abc", null) = "abc"
StringUtil.trim("abc ", null) = "abc"
StringUtil.trim(" abc ", null) = "abc"
StringUtil.trim(" abcyx", "xyz") = " abc"
str 要处理的字符串
stripChars 要除去的字符,如果为null表示除去空白字符
除去空白的字符串,如果原字串为null或结果字符串为"",则返回nullpublic static String trimToEmpty(String str)
null,则返回空字符串""。
注意,和String.trim不同,此方法使用Character.isWhitespace来判定空白,
因而可以除去英文字符集之外的其它空白,如中文空格。
StringUtil.trimToEmpty(null) = ""
StringUtil.trimToEmpty("") = ""
StringUtil.trimToEmpty(" ") = ""
StringUtil.trimToEmpty("abc") = "abc"
StringUtil.trimToEmpty(" abc ") = "abc"
str 要处理的字符串
除去空白的字符串,如果原字串为null或结果字符串为"",则返回nullpublic static String trimToEmpty(String str, String stripChars)
null,则返回空字符串""。
注意,和String.trim不同,此方法使用Character.isWhitespace来判定空白,
因而可以除去英文字符集之外的其它空白,如中文空格。
StringUtil.trim(null, *) = ""
StringUtil.trim("", *) = ""
StringUtil.trim("abc", null) = "abc"
StringUtil.trim(" abc", null) = "abc"
StringUtil.trim("abc ", null) = "abc"
StringUtil.trim(" abc ", null) = "abc"
StringUtil.trim(" abcyx", "xyz") = " abc"
str 要处理的字符串
除去空白的字符串,如果原字串为null或结果字符串为"",则返回nullpublic static boolean equals(String str1, String str2)
StringUtil.equals(null, null) = true
StringUtil.equals(null, "abc") = false
StringUtil.equals("abc", null) = false
StringUtil.equals("abc", "abc") = true
StringUtil.equals("abc", "ABC") = false
str1 要比较的字符串1
str2 要比较的字符串2
如果两个字符串相同,或者都是null,则返回truepublic static boolean equalsIgnoreCase(String str1, String str2)
StringUtil.equalsIgnoreCase(null, null) = true
StringUtil.equalsIgnoreCase(null, "abc") = false
StringUtil.equalsIgnoreCase("abc", null) = false
StringUtil.equalsIgnoreCase("abc", "abc") = true
StringUtil.equalsIgnoreCase("abc", "ABC") = true
str1 要比较的字符串1
str2 要比较的字符串2
如果两个字符串相同,或者都是null,则返回truepublic static boolean isAlpha(String str)
null将返回false,空字符串""将返回true。
StringUtil.isAlpha(null) = false
StringUtil.isAlpha("") = true
StringUtil.isAlpha(" ") = false
StringUtil.isAlpha("abc") = true
StringUtil.isAlpha("ab2c") = false
StringUtil.isAlpha("ab-c") = false
str 要检查的字符串
如果字符串非null并且全由unicode字母组成,则返回truepublic static boolean isAlphaSpace(String str)
' '。
null将返回false,空字符串""将返回true。
StringUtil.isAlphaSpace(null) = false
StringUtil.isAlphaSpace("") = true
StringUtil.isAlphaSpace(" ") = true
StringUtil.isAlphaSpace("abc") = true
StringUtil.isAlphaSpace("ab c") = true
StringUtil.isAlphaSpace("ab2c") = false
StringUtil.isAlphaSpace("ab-c") = false
str 要检查的字符串
如果字符串非null并且全由unicode字母和空格组成,则返回truepublic static boolean isAlphanumeric(String str)
null将返回false,空字符串""将返回true。
StringUtil.isAlphanumeric(null) = false
StringUtil.isAlphanumeric("") = true
StringUtil.isAlphanumeric(" ") = false
StringUtil.isAlphanumeric("abc") = true
StringUtil.isAlphanumeric("ab c") = false
StringUtil.isAlphanumeric("ab2c") = true
StringUtil.isAlphanumeric("ab-c") = false
str 要检查的字符串
如果字符串非null并且全由unicode字母数字组成,则返回truepublic static boolean isAlphanumericSpace(String str)
' '。
null将返回false,空字符串""将返回true。
StringUtil.isAlphanumericSpace(null) = false
StringUtil.isAlphanumericSpace("") = true
StringUtil.isAlphanumericSpace(" ") = true
StringUtil.isAlphanumericSpace("abc") = true
StringUtil.isAlphanumericSpace("ab c") = true
StringUtil.isAlphanumericSpace("ab2c") = true
StringUtil.isAlphanumericSpace("ab-c") = false
str 要检查的字符串
如果字符串非null并且全由unicode字母数字和空格组成,则返回truepublic static boolean isNumeric(String str)
null将返回false,空字符串""将返回true。
StringUtil.isNumeric(null) = false
StringUtil.isNumeric("") = true
StringUtil.isNumeric(" ") = false
StringUtil.isNumeric("123") = true
StringUtil.isNumeric("12 3") = false
StringUtil.isNumeric("ab2c") = false
StringUtil.isNumeric("12-3") = false
StringUtil.isNumeric("12.3") = false
str 要检查的字符串
如果字符串非null并且全由unicode数字组成,则返回truepublic static boolean isNumericSpace(String str)
' '。
null将返回false,空字符串""将返回true。
StringUtil.isNumericSpace(null) = false
StringUtil.isNumericSpace("") = true
StringUtil.isNumericSpace(" ") = true
StringUtil.isNumericSpace("123") = true
StringUtil.isNumericSpace("12 3") = true
StringUtil.isNumericSpace("ab2c") = false
StringUtil.isNumericSpace("12-3") = false
StringUtil.isNumericSpace("12.3") = false
str 要检查的字符串
如果字符串非null并且全由unicode数字和空格组成,则返回truepublic static boolean isWhitespace(String str)
null将返回false,空字符串""将返回true。
StringUtil.isWhitespace(null) = false
StringUtil.isWhitespace("") = true
StringUtil.isWhitespace(" ") = true
StringUtil.isWhitespace("abc") = false
StringUtil.isWhitespace("ab2c") = false
StringUtil.isWhitespace("ab-c") = false
str 要检查的字符串
如果字符串非null并且全由unicode空白组成,则返回truepublic static String toUpperCase(String str)
null则返回null。
StringUtil.toUpperCase(null) = null
StringUtil.toUpperCase("") = ""
StringUtil.toUpperCase("aBc") = "ABC"
str 要转换的字符串
大写字符串,如果原字符串为null,则返回nullpublic static String toLowerCase(String str)
null则返回null。
StringUtil.toLowerCase(null) = null
StringUtil.toLowerCase("") = ""
StringUtil.toLowerCase("aBc") = "abc"
str 要转换的字符串
大写字符串,如果原字符串为null,则返回nullpublic static String capitalize(String str)
Character.toTitleCase),其它字符不变。
如果字符串是null则返回null。
StringUtil.capitalize(null) = null
StringUtil.capitalize("") = ""
StringUtil.capitalize("cat") = "Cat"
StringUtil.capitalize("cAt") = "CAt"
str 要转换的字符串
首字符为大写的字符串,如果原字符串为null,则返回nullpublic static String uncapitalize(String str)
null则返回null。
StringUtil.uncapitalize(null) = null
StringUtil.uncapitalize("") = ""
StringUtil.uncapitalize("Cat") = "cat"
StringUtil.uncapitalize("CAT") = "cAT"
str 要转换的字符串
首字符为小写的字符串,如果原字符串为null,则返回nullpublic static String swapCase(String str)
null则返回null。
StringUtil.swapCase(null) = null
StringUtil.swapCase("") = ""
StringUtil.swapCase("The dog has a BONE") = "tHE DOG HAS A bone"
str 要转换的字符串
大小写被反转的字符串,如果原字符串为null,则返回nullpublic static String toCamelCase(String str)
null则返回null。
StringUtil.toCamelCase(null) = null
StringUtil.toCamelCase("") = ""
StringUtil.toCamelCase("aBc") = "aBc"
StringUtil.toCamelCase("aBc def") = "aBcDef"
StringUtil.toCamelCase("aBc def_ghi") = "aBcDefGhi"
StringUtil.toCamelCase("aBc def_ghi 123") = "aBcDefGhi123"
此方法会保留除了下划线和空白以外的所有分隔符。
str 要转换的字符串
camel case字符串,如果原字符串为null,则返回nullpublic static String toPascalCase(String str)
null则返回null。
StringUtil.toPascalCase(null) = null
StringUtil.toPascalCase("") = ""
StringUtil.toPascalCase("aBc") = "ABc"
StringUtil.toPascalCase("aBc def") = "ABcDef"
StringUtil.toPascalCase("aBc def_ghi") = "ABcDefGhi"
StringUtil.toPascalCase("aBc def_ghi 123") = "aBcDefGhi123"
此方法会保留除了下划线和空白以外的所有分隔符。
str 要转换的字符串
pascal case字符串,如果原字符串为null,则返回nullpublic static String toUpperCaseWithUnderscores(String str)
null则返回null。
StringUtil.toUpperCaseWithUnderscores(null) = null
StringUtil.toUpperCaseWithUnderscores("") = ""
StringUtil.toUpperCaseWithUnderscores("aBc") = "A_BC"
StringUtil.toUpperCaseWithUnderscores("aBc def") = "A_BC_DEF"
StringUtil.toUpperCaseWithUnderscores("aBc def_ghi") = "A_BC_DEF_GHI"
StringUtil.toUpperCaseWithUnderscores("aBc def_ghi 123") = "A_BC_DEF_GHI_123"
StringUtil.toUpperCaseWithUnderscores("__a__Bc__") = "__A__BC__"
此方法会保留除了空白以外的所有分隔符。
str 要转换的字符串
下划线分隔的大写字符串,如果原字符串为null,则返回nullpublic static String toLowerCaseWithUnderscores(String str)
null则返回null。
StringUtil.toLowerCaseWithUnderscores(null) = null
StringUtil.toLowerCaseWithUnderscores("") = ""
StringUtil.toLowerCaseWithUnderscores("aBc") = "a_bc"
StringUtil.toLowerCaseWithUnderscores("aBc def") = "a_bc_def"
StringUtil.toLowerCaseWithUnderscores("aBc def_ghi") = "a_bc_def_ghi"
StringUtil.toLowerCaseWithUnderscores("aBc def_ghi 123") = "a_bc_def_ghi_123"
StringUtil.toLowerCaseWithUnderscores("__a__Bc__") = "__a__bc__"
此方法会保留除了空白以外的所有分隔符。
str 要转换的字符串
下划线分隔的小写字符串,如果原字符串为null,则返回nullpublic static String[] split(String str)
null,则返回null。
StringUtil.split(null) = null
StringUtil.split("") = []
StringUtil.split("abc def") = ["abc", "def"]
StringUtil.split("abc def") = ["abc", "def"]
StringUtil.split(" abc ") = ["abc"]
str 要分割的字符串
分割后的字符串数组,如果原字符串为null,则返回nullpublic static String[] split(String str, char separatorChar)
null,则返回null。
StringUtil.split(null, *) = null
StringUtil.split("", *) = []
StringUtil.split("a.b.c", '.') = ["a", "b", "c"]
StringUtil.split("a..b.c", '.') = ["a", "b", "c"]
StringUtil.split("a:b:c", '.') = ["a:b:c"]
StringUtil.split("a b c", ' ') = ["a", "b", "c"]
str 要分割的字符串
separatorChar 分隔符
分割后的字符串数组,如果原字符串为null,则返回nullpublic static String[] split(String str, String separatorChars)
null,则返回null。
StringUtil.split(null, *) = null
StringUtil.split("", *) = []
StringUtil.split("abc def", null) = ["abc", "def"]
StringUtil.split("abc def", " ") = ["abc", "def"]
StringUtil.split("abc def", " ") = ["abc", "def"]
StringUtil.split(" ab: cd::ef ", ":") = ["ab", "cd", "ef"]
StringUtil.split("abc.def", "") = ["abc.def"]
str 要分割的字符串
separatorChars 分隔符
分割后的字符串数组,如果原字符串为null,则返回nullpublic static String[] split(String str, String separatorChars, int max)
null,则返回null。
StringUtil.split(null, *, *) = null
StringUtil.split("", *, *) = []
StringUtil.split("ab cd ef", null, 0) = ["ab", "cd", "ef"]
StringUtil.split(" ab cd ef ", null, 0) = ["ab", "cd", "ef"]
StringUtil.split("ab:cd::ef", ":", 0) = ["ab", "cd", "ef"]
StringUtil.split("ab:cd:ef", ":", 2) = ["ab", "cdef"]
StringUtil.split("abc.def", "", 2) = ["abc.def"]
str 要分割的字符串
separatorChars 分隔符
max 返回的数组的最大个数,如果小于等于0,则表示无限制
分割后的字符串数组,如果原字符串为null,则返回nullpublic static String join(Object[] array)
StringUtil.join(null) = null StringUtil.join([]) = "" StringUtil.join([null]) = "" StringUtil.join(["a", "b", "c"]) = "abc" StringUtil.join([null, "", "a"]) = "a"array 要连接的数组 连接后的字符串,如果原数组为
null,则返回nullpublic static String join(Object[] array, char separator)
StringUtil.join(null, *) = null StringUtil.join([], *) = "" StringUtil.join([null], *) = "" StringUtil.join(["a", "b", "c"], ';') = "a;b;c" StringUtil.join(["a", "b", "c"], null) = "abc" StringUtil.join([null, "", "a"], ';') = ";;a"array 要连接的数组 separator 分隔符 连接后的字符串,如果原数组为
null,则返回nullpublic static String join(Object[] array, String separator)
StringUtil.join(null, *) = null StringUtil.join([], *) = "" StringUtil.join([null], *) = "" StringUtil.join(["a", "b", "c"], "--") = "a--b--c" StringUtil.join(["a", "b", "c"], null) = "abc" StringUtil.join(["a", "b", "c"], "") = "abc" StringUtil.join([null, "", "a"], ',') = ",,a"array 要连接的数组 separator 分隔符 连接后的字符串,如果原数组为
null,则返回nullpublic static String join(Iterator iterator, char separator)
Iterator中的元素连接成一个字符串。
StringUtil.join(null, *) = null StringUtil.join([], *) = "" StringUtil.join([null], *) = "" StringUtil.join(["a", "b", "c"], "--") = "a--b--c" StringUtil.join(["a", "b", "c"], null) = "abc" StringUtil.join(["a", "b", "c"], "") = "abc" StringUtil.join([null, "", "a"], ',') = ",,a"iterator 要连接的
Iterator
separator 分隔符
连接后的字符串,如果原数组为null,则返回nullpublic static String join(Iterator iterator, String separator)
Iterator中的元素连接成一个字符串。
StringUtil.join(null, *) = null StringUtil.join([], *) = "" StringUtil.join([null], *) = "" StringUtil.join(["a", "b", "c"], "--") = "a--b--c" StringUtil.join(["a", "b", "c"], null) = "abc" StringUtil.join(["a", "b", "c"], "") = "abc" StringUtil.join([null, "", "a"], ',') = ",,a"iterator 要连接的
Iterator
separator 分隔符
连接后的字符串,如果原数组为null,则返回nullpublic static int indexOf(String str, char searchChar)
null或未找到,则返回-1。
StringUtil.indexOf(null, *) = -1
StringUtil.indexOf("", *) = -1
StringUtil.indexOf("aabaabaa", 'a') = 0
StringUtil.indexOf("aabaabaa", 'b') = 2
str 要扫描的字符串
searchChar 要查找的字符
第一个匹配的索引值。如果字符串为null或未找到,则返回-1public static int indexOf(String str, char searchChar, int startPos)
null或未找到,则返回-1。
StringUtil.indexOf(null, *, *) = -1
StringUtil.indexOf("", *, *) = -1
StringUtil.indexOf("aabaabaa", 'b', 0) = 2
StringUtil.indexOf("aabaabaa", 'b', 3) = 5
StringUtil.indexOf("aabaabaa", 'b', 9) = -1
StringUtil.indexOf("aabaabaa", 'b', -1) = 2
str 要扫描的字符串
searchChar 要查找的字符
startPos 开始搜索的索引值,如果小于0,则看作0
第一个匹配的索引值。如果字符串为null或未找到,则返回-1public static int indexOf(String str, String searchStr)
null或未找到,则返回-1。
StringUtil.indexOf(null, *) = -1
StringUtil.indexOf(*, null) = -1
StringUtil.indexOf("", "") = 0
StringUtil.indexOf("aabaabaa", "a") = 0
StringUtil.indexOf("aabaabaa", "b") = 2
StringUtil.indexOf("aabaabaa", "ab") = 1
StringUtil.indexOf("aabaabaa", "") = 0
str 要扫描的字符串
searchStr 要查找的字符串
第一个匹配的索引值。如果字符串为null或未找到,则返回-1public static int indexOf(String str, String searchStr, int startPos)
null或未找到,则返回-1。
StringUtil.indexOf(null, *, *) = -1
StringUtil.indexOf(*, null, *) = -1
StringUtil.indexOf("", "", 0) = 0
StringUtil.indexOf("aabaabaa", "a", 0) = 0
StringUtil.indexOf("aabaabaa", "b", 0) = 2
StringUtil.indexOf("aabaabaa", "ab", 0) = 1
StringUtil.indexOf("aabaabaa", "b", 3) = 5
StringUtil.indexOf("aabaabaa", "b", 9) = -1
StringUtil.indexOf("aabaabaa", "b", -1) = 2
StringUtil.indexOf("aabaabaa", "", 2) = 2
StringUtil.indexOf("abc", "", 9) = 3
str 要扫描的字符串
searchStr 要查找的字符串
startPos 开始搜索的索引值,如果小于0,则看作0
第一个匹配的索引值。如果字符串为null或未找到,则返回-1public static int indexOfAny(String str, char[] searchChars)
null,则返回-1。
如果字符集合为null或空,也返回-1。
StringUtil.indexOfAny(null, *) = -1
StringUtil.indexOfAny("", *) = -1
StringUtil.indexOfAny(*, null) = -1
StringUtil.indexOfAny(*, []) = -1
StringUtil.indexOfAny("zzabyycdxx",['z','a']) = 0
StringUtil.indexOfAny("zzabyycdxx",['b','y']) = 3
StringUtil.indexOfAny("aba", ['z']) = -1
str 要扫描的字符串
searchChars 要搜索的字符集合
第一个匹配的索引值。如果字符串为null或未找到,则返回-1public static int indexOfAny(String str, String searchChars)
null,则返回-1。
如果字符集合为null或空,也返回-1。
StringUtil.indexOfAny(null, *) = -1
StringUtil.indexOfAny("", *) = -1
StringUtil.indexOfAny(*, null) = -1
StringUtil.indexOfAny(*, "") = -1
StringUtil.indexOfAny("zzabyycdxx", "za") = 0
StringUtil.indexOfAny("zzabyycdxx", "by") = 3
StringUtil.indexOfAny("aba","z") = -1
str 要扫描的字符串
searchChars 要搜索的字符集合
第一个匹配的索引值。如果字符串为null或未找到,则返回-1public static int indexOfAny(String str, String[] searchStrs)
null,则返回-1。
如果字符串集合为null或空,也返回-1。
如果字符串集合包括"",并且字符串不为null,则返回str.length()
StringUtil.indexOfAny(null, *) = -1
StringUtil.indexOfAny(*, null) = -1
StringUtil.indexOfAny(*, []) = -1
StringUtil.indexOfAny("zzabyycdxx", ["ab","cd"]) = 2
StringUtil.indexOfAny("zzabyycdxx", ["cd","ab"]) = 2
StringUtil.indexOfAny("zzabyycdxx", ["mn","op"]) = -1
StringUtil.indexOfAny("zzabyycdxx", ["zab","aby"]) = 1
StringUtil.indexOfAny("zzabyycdxx", [""]) = 0
StringUtil.indexOfAny("", [""]) = 0
StringUtil.indexOfAny("", ["a"]) = -1
str 要扫描的字符串
searchStrs 要搜索的字符串集合
第一个匹配的索引值。如果字符串为null或未找到,则返回-1public static int indexOfAnyBut(String str, char[] searchChars)
null,则返回-1。
如果字符集合为null或空,也返回-1。
StringUtil.indexOfAnyBut(null, *) = -1
StringUtil.indexOfAnyBut("", *) = -1
StringUtil.indexOfAnyBut(*, null) = -1
StringUtil.indexOfAnyBut(*, []) = -1
StringUtil.indexOfAnyBut("zzabyycdxx",'za') = 3
StringUtil.indexOfAnyBut("zzabyycdxx", 'by') = 0
StringUtil.indexOfAnyBut("aba", 'ab') = -1
str 要扫描的字符串
searchChars 要搜索的字符集合
第一个匹配的索引值。如果字符串为null或未找到,则返回-1public static int indexOfAnyBut(String str, String searchChars)
null,则返回-1。
如果字符集合为null或空,也返回-1。
StringUtil.indexOfAnyBut(null, *) = -1
StringUtil.indexOfAnyBut("", *) = -1
StringUtil.indexOfAnyBut(*, null) = -1
StringUtil.indexOfAnyBut(*, "") = -1
StringUtil.indexOfAnyBut("zzabyycdxx", "za") = 3
StringUtil.indexOfAnyBut("zzabyycdxx", "by") = 0
StringUtil.indexOfAnyBut("aba","ab") = -1
str 要扫描的字符串
searchChars 要搜索的字符集合
第一个匹配的索引值。如果字符串为null或未找到,则返回-1public static int lastIndexOf(String str, char searchChar)
null或未找到,则返回-1。
StringUtil.lastIndexOf(null, *) = -1
StringUtil.lastIndexOf("", *) = -1
StringUtil.lastIndexOf("aabaabaa", 'a') = 7
StringUtil.lastIndexOf("aabaabaa", 'b') = 5
str 要扫描的字符串
searchChar 要查找的字符
第一个匹配的索引值。如果字符串为null或未找到,则返回-1public static int lastIndexOf(String str, char searchChar, int startPos)
null或未找到,则返回-1。
StringUtil.lastIndexOf(null, *, *) = -1
StringUtil.lastIndexOf("", *, *) = -1
StringUtil.lastIndexOf("aabaabaa", 'b', 8) = 5
StringUtil.lastIndexOf("aabaabaa", 'b', 4) = 2
StringUtil.lastIndexOf("aabaabaa", 'b', 0) = -1
StringUtil.lastIndexOf("aabaabaa", 'b', 9) = 5
StringUtil.lastIndexOf("aabaabaa", 'b', -1) = -1
StringUtil.lastIndexOf("aabaabaa", 'a', 0) = 0
str 要扫描的字符串
searchChar 要查找的字符
startPos 从指定索引开始向前搜索
第一个匹配的索引值。如果字符串为null或未找到,则返回-1public static int lastIndexOf(String str, String searchStr)
null或未找到,则返回-1。
StringUtil.lastIndexOf(null, *) = -1
StringUtil.lastIndexOf("", *) = -1
StringUtil.lastIndexOf("aabaabaa", 'a') = 7
StringUtil.lastIndexOf("aabaabaa", 'b') = 5
str 要扫描的字符串
searchStr 要查找的字符串
第一个匹配的索引值。如果字符串为null或未找到,则返回-1public static int lastIndexOf(String str, String searchStr, int startPos)
null或未找到,则返回-1。
StringUtil.lastIndexOf(null, *, *) = -1
StringUtil.lastIndexOf(*, null, *) = -1
StringUtil.lastIndexOf("aabaabaa", "a", 8) = 7
StringUtil.lastIndexOf("aabaabaa", "b", 8) = 5
StringUtil.lastIndexOf("aabaabaa", "ab", 8) = 4
StringUtil.lastIndexOf("aabaabaa", "b", 9) = 5
StringUtil.lastIndexOf("aabaabaa", "b", -1) = -1
StringUtil.lastIndexOf("aabaabaa", "a", 0) = 0
StringUtil.lastIndexOf("aabaabaa", "b", 0) = -1
str 要扫描的字符串
searchStr 要查找的字符串
startPos 从指定索引开始向前搜索
第一个匹配的索引值。如果字符串为null或未找到,则返回-1public static int lastIndexOfAny(String str, String[] searchStrs)
null,则返回-1。
如果字符串集合为null或空,也返回-1。
如果字符串集合包括"",并且字符串不为null,则返回str.length()
StringUtil.lastIndexOfAny(null, *) = -1
StringUtil.lastIndexOfAny(*, null) = -1
StringUtil.lastIndexOfAny(*, []) = -1
StringUtil.lastIndexOfAny(*, [null]) = -1
StringUtil.lastIndexOfAny("zzabyycdxx", ["ab","cd"]) = 6
StringUtil.lastIndexOfAny("zzabyycdxx", ["cd","ab"]) = 6
StringUtil.lastIndexOfAny("zzabyycdxx", ["mn","op"]) = -1
StringUtil.lastIndexOfAny("zzabyycdxx", ["mn","op"]) = -1
StringUtil.lastIndexOfAny("zzabyycdxx", ["mn",""]) = 10
str 要扫描的字符串
searchStrs 要搜索的字符串集合
第一个匹配的索引值。如果字符串为null或未找到,则返回-1public static boolean contains(String str, char searchChar)
null,将返回false。
StringUtil.contains(null, *) = false
StringUtil.contains("", *) = false
StringUtil.contains("abc", 'a') = true
StringUtil.contains("abc", 'z') = false
str 要扫描的字符串
searchChar 要查找的字符
如果找到,则返回truepublic static boolean contains(String str, String searchStr)
null,将返回false。
StringUtil.contains(null, *) = false
StringUtil.contains(*, null) = false
StringUtil.contains("", "") = true
StringUtil.contains("abc", "") = true
StringUtil.contains("abc", "a") = true
StringUtil.contains("abc", "z") = false
str 要扫描的字符串
searchStr 要查找的字符串
如果找到,则返回truepublic static boolean containsOnly(String str, char[] valid)
null,则返回false。
如果字符集合为null则返回false。 但是空字符串永远返回true.
StringUtil.containsOnly(null, *) = false
StringUtil.containsOnly(*, null) = false
StringUtil.containsOnly("", *) = true
StringUtil.containsOnly("ab", '') = false
StringUtil.containsOnly("abab", 'abc') = true
StringUtil.containsOnly("ab1", 'abc') = false
StringUtil.containsOnly("abz", 'abc') = false
str 要扫描的字符串
valid 要查找的字符串
如果找到,则返回truepublic static boolean containsOnly(String str, String valid)
null,则返回false。
如果字符集合为null则返回false。 但是空字符串永远返回true.
StringUtil.containsOnly(null, *) = false
StringUtil.containsOnly(*, null) = false
StringUtil.containsOnly("", *) = true
StringUtil.containsOnly("ab", "") = false
StringUtil.containsOnly("abab", "abc") = true
StringUtil.containsOnly("ab1", "abc") = false
StringUtil.containsOnly("abz", "abc") = false
str 要扫描的字符串
valid 要查找的字符串
如果找到,则返回truepublic static boolean containsNone(String str, char[] invalid)
null,则返回false。 如果字符集合为null则返回true。
但是空字符串永远返回true.
StringUtil.containsNone(null, *) = true
StringUtil.containsNone(*, null) = true
StringUtil.containsNone("", *) = true
StringUtil.containsNone("ab", '') = true
StringUtil.containsNone("abab", 'xyz') = true
StringUtil.containsNone("ab1", 'xyz') = true
StringUtil.containsNone("abz", 'xyz') = false
str 要扫描的字符串
invalid 要查找的字符串
如果找到,则返回truepublic static boolean containsNone(String str, String invalidChars)
null,则返回false。 如果字符集合为null则返回true。
但是空字符串永远返回true.
StringUtil.containsNone(null, *) = true
StringUtil.containsNone(*, null) = true
StringUtil.containsNone("", *) = true
StringUtil.containsNone("ab", "") = true
StringUtil.containsNone("abab", "xyz") = true
StringUtil.containsNone("ab1", "xyz") = true
StringUtil.containsNone("abz", "xyz") = false
str 要扫描的字符串
invalidChars 要查找的字符串
如果找到,则返回truepublic static int countMatches(String str, String subStr)
null或空,则返回0。
StringUtil.countMatches(null, *) = 0
StringUtil.countMatches("", *) = 0
StringUtil.countMatches("abba", null) = 0
StringUtil.countMatches("abba", "") = 0
StringUtil.countMatches("abba", "a") = 2
StringUtil.countMatches("abba", "ab") = 1
StringUtil.countMatches("abba", "xxx") = 0
str 要扫描的字符串
subStr 子字符串
子串在字符串中出现的次数,如果字符串为null或空,则返回0public static String substring(String str, int start)
null,则返回null。
StringUtil.substring(null, *) = null
StringUtil.substring("", *) = ""
StringUtil.substring("abc", 0) = "abc"
StringUtil.substring("abc", 2) = "c"
StringUtil.substring("abc", 4) = ""
StringUtil.substring("abc", -2) = "bc"
StringUtil.substring("abc", -4) = "abc"
str 字符串
start 起始索引,如果为负数,表示从尾部查找
子串,如果原始串为null,则返回nullpublic static String substring(String str, int start, int end)
null,则返回null。
StringUtil.substring(null, *, *) = null
StringUtil.substring("", * , *) = "";
StringUtil.substring("abc", 0, 2) = "ab"
StringUtil.substring("abc", 2, 0) = ""
StringUtil.substring("abc", 2, 4) = "c"
StringUtil.substring("abc", 4, 6) = ""
StringUtil.substring("abc", 2, 2) = ""
StringUtil.substring("abc", -2, -1) = "b"
StringUtil.substring("abc", -4, 2) = "ab"
str 字符串
start 起始索引,如果为负数,表示从尾部计算
end 结束索引(不含),如果为负数,表示从尾部计算
子串,如果原始串为null,则返回nullpublic static String left(String str, int len)
StringUtil.left(null, *) = null
StringUtil.left(*, -ve) = ""
StringUtil.left("", *) = ""
StringUtil.left("abc", 0) = ""
StringUtil.left("abc", 2) = "ab"
StringUtil.left("abc", 4) = "abc"
str 字符串
len 最左子串的长度
子串,如果原始字串为null,则返回nullpublic static String right(String str, int len)
StringUtil.right(null, *) = null
StringUtil.right(*, -ve) = ""
StringUtil.right("", *) = ""
StringUtil.right("abc", 0) = ""
StringUtil.right("abc", 2) = "bc"
StringUtil.right("abc", 4) = "abc"
str 字符串
len 最右子串的长度
子串,如果原始字串为null,则返回nullpublic static String mid(String str, int pos, int len)
StringUtil.mid(null, *, *) = null
StringUtil.mid(*, *, -ve) = ""
StringUtil.mid("", 0, *) = ""
StringUtil.mid("abc", 0, 2) = "ab"
StringUtil.mid("abc", 0, 4) = "abc"
StringUtil.mid("abc", 2, 4) = "c"
StringUtil.mid("abc", 4, 2) = ""
StringUtil.mid("abc", -2, 2) = "ab"
str 字符串
pos 起始索引,如果为负数,则看作0
len 子串的长度,如果为负数,则看作长度为0
子串,如果原始字串为null,则返回nullpublic static String substringBefore(String str, String separator)
null,则返回null。 如果分隔子串为null或未找到该子串,则返回原字符串。
StringUtil.substringBefore(null, *) = null
StringUtil.substringBefore("", *) = ""
StringUtil.substringBefore("abc", "a") = ""
StringUtil.substringBefore("abcba", "b") = "a"
StringUtil.substringBefore("abc", "c") = "ab"
StringUtil.substringBefore("abc", "d") = "abc"
StringUtil.substringBefore("abc", "") = ""
StringUtil.substringBefore("abc", null) = "abc"
str 字符串
separator 要搜索的分隔子串
子串,如果原始串为null,则返回nullpublic static String substringAfter(String str, String separator)
null,则返回null。 如果分隔子串为null或未找到该子串,则返回原字符串。
StringUtil.substringAfter(null, *) = null
StringUtil.substringAfter("", *) = ""
StringUtil.substringAfter(*, null) = ""
StringUtil.substringAfter("abc", "a") = "bc"
StringUtil.substringAfter("abcba", "b") = "cba"
StringUtil.substringAfter("abc", "c") = ""
StringUtil.substringAfter("abc", "d") = ""
StringUtil.substringAfter("abc", "") = "abc"
str 字符串
separator 要搜索的分隔子串
子串,如果原始串为null,则返回nullpublic static String substringBeforeLast(String str, String separator)
null,则返回null。 如果分隔子串为null或未找到该子串,则返回原字符串。
StringUtil.substringBeforeLast(null, *) = null
StringUtil.substringBeforeLast("", *) = ""
StringUtil.substringBeforeLast("abcba", "b") = "abc"
StringUtil.substringBeforeLast("abc", "c") = "ab"
StringUtil.substringBeforeLast("a", "a") = ""
StringUtil.substringBeforeLast("a", "z") = "a"
StringUtil.substringBeforeLast("a", null) = "a"
StringUtil.substringBeforeLast("a", "") = "a"
str 字符串
separator 要搜索的分隔子串
子串,如果原始串为null,则返回nullpublic static String substringAfterLast(String str, String separator)
null,则返回null。 如果分隔子串为null或未找到该子串,则返回原字符串。
StringUtil.substringAfterLast(null, *) = null
StringUtil.substringAfterLast("", *) = ""
StringUtil.substringAfterLast(*, "") = ""
StringUtil.substringAfterLast(*, null) = ""
StringUtil.substringAfterLast("abc", "a") = "bc"
StringUtil.substringAfterLast("abcba", "b") = "a"
StringUtil.substringAfterLast("abc", "c") = ""
StringUtil.substringAfterLast("a", "a") = ""
StringUtil.substringAfterLast("a", "z") = ""
str 字符串
separator 要搜索的分隔子串
子串,如果原始串为null,则返回nullpublic static String substringBetween(String str, String tag)
null,则返回null。 如果分隔子串为null,则返回null。
StringUtil.substringBetween(null, *) = null
StringUtil.substringBetween("", "") = ""
StringUtil.substringBetween("", "tag") = null
StringUtil.substringBetween("tagabctag", null) = null
StringUtil.substringBetween("tagabctag", "") = ""
StringUtil.substringBetween("tagabctag", "tag") = "abc"
str 字符串
tag 要搜索的分隔子串
子串,如果原始串为null或未找到分隔子串,则返回nullpublic static String substringBetween(String str, String open, String close)
null,则返回null。 如果分隔子串为null,则返回null。
StringUtil.substringBetween(null, *, *) = null
StringUtil.substringBetween("", "", "") = ""
StringUtil.substringBetween("", "", "tag") = null
StringUtil.substringBetween("", "tag", "tag") = null
StringUtil.substringBetween("yabcz", null, null) = null
StringUtil.substringBetween("yabcz", "", "") = ""
StringUtil.substringBetween("yabcz", "y", "z") = "abc"
StringUtil.substringBetween("yabczyabcz", "y", "z") = "abc"
str 字符串
open 要搜索的分隔子串1
close 要搜索的分隔子串2
子串,如果原始串为null或未找到分隔子串,则返回nullpublic static String substringBetween(String str, String open, String close, int fromIndex)
null,则返回null。 如果分隔子串为null,则返回null。
StringUtil.substringBetween(null, *, *) = null
StringUtil.substringBetween("", "", "") = ""
StringUtil.substringBetween("", "", "tag") = null
StringUtil.substringBetween("", "tag", "tag") = null
StringUtil.substringBetween("yabcz", null, null) = null
StringUtil.substringBetween("yabcz", "", "") = ""
StringUtil.substringBetween("yabcz", "y", "z") = "abc"
StringUtil.substringBetween("yabczyabcz", "y", "z") = "abc"
str 字符串
open 要搜索的分隔子串1
close 要搜索的分隔子串2
fromIndex 从指定index处搜索
子串,如果原始串为null或未找到分隔子串,则返回nullpublic static String deleteWhitespace(String str)
Character.isWhitespace(char)中所定义的空白。
StringUtil.deleteWhitespace(null) = null
StringUtil.deleteWhitespace("") = ""
StringUtil.deleteWhitespace("abc") = "abc"
StringUtil.deleteWhitespace(" ab c ") = "abc"
str 要处理的字符串
去空白后的字符串,如果原始字符串为null,则返回nullpublic static String replaceOnce(String text, String repl, String with)
null则返回null,如果指定子串为null,则返回原字符串。
StringUtil.replaceOnce(null, *, *) = null
StringUtil.replaceOnce("", *, *) = ""
StringUtil.replaceOnce("aba", null, null) = "aba"
StringUtil.replaceOnce("aba", null, null) = "aba"
StringUtil.replaceOnce("aba", "a", null) = "aba"
StringUtil.replaceOnce("aba", "a", "") = "ba"
StringUtil.replaceOnce("aba", "a", "z") = "zba"
text 要扫描的字符串
repl 要搜索的子串
with 替换字符串
被替换后的字符串,如果原始字符串为null,则返回nullpublic static String replace(String text, String repl, String with)
null则返回null,如果指定子串为null,则返回原字符串。
StringUtil.replace(null, *, *) = null
StringUtil.replace("", *, *) = ""
StringUtil.replace("aba", null, null) = "aba"
StringUtil.replace("aba", null, null) = "aba"
StringUtil.replace("aba", "a", null) = "aba"
StringUtil.replace("aba", "a", "") = "b"
StringUtil.replace("aba", "a", "z") = "zbz"
text 要扫描的字符串
repl 要搜索的子串
with 替换字符串
被替换后的字符串,如果原始字符串为null,则返回nullpublic static String replace(String text, String repl, String with, int max)
null则返回null,如果指定子串为null,则返回原字符串。
StringUtil.replace(null, *, *, *) = null
StringUtil.replace("", *, *, *) = ""
StringUtil.replace("abaa", null, null, 1) = "abaa"
StringUtil.replace("abaa", null, null, 1) = "abaa"
StringUtil.replace("abaa", "a", null, 1) = "abaa"
StringUtil.replace("abaa", "a", "", 1) = "baa"
StringUtil.replace("abaa", "a", "z", 0) = "abaa"
StringUtil.replace("abaa", "a", "z", 1) = "zbaa"
StringUtil.replace("abaa", "a", "z", 2) = "zbza"
StringUtil.replace("abaa", "a", "z", -1) = "zbzz"
text 要扫描的字符串
repl 要搜索的子串
with 替换字符串
max maximum number of values to replace, or -1 if no maximum
被替换后的字符串,如果原始字符串为null,则返回nullpublic static String replaceChars(String str, char searchChar, char replaceChar)
null则返回null。
StringUtil.replaceChars(null, *, *) = null
StringUtil.replaceChars("", *, *) = ""
StringUtil.replaceChars("abcba", 'b', 'y') = "aycya"
StringUtil.replaceChars("abcba", 'z', 'y') = "abcba"
str 要扫描的字符串
searchChar 要搜索的字符
replaceChar 替换字符
被替换后的字符串,如果原始字符串为null,则返回nullpublic static String replaceChars(String str, String searchChars, String replaceChars)
null则返回null。如果搜索字符串为null或空,则返回原字符串。
例如: replaceChars("hello", "ho", "jy") = jelly。
通常搜索字符串和替换字符串是等长的,如果搜索字符串比替换字符串长,则多余的字符将被删除。 如果搜索字符串比替换字符串短,则缺少的字符将被忽略。
StringUtil.replaceChars(null, *, *) = null
StringUtil.replaceChars("", *, *) = ""
StringUtil.replaceChars("abc", null, *) = "abc"
StringUtil.replaceChars("abc", "", *) = "abc"
StringUtil.replaceChars("abc", "b", null) = "ac"
StringUtil.replaceChars("abc", "b", "") = "ac"
StringUtil.replaceChars("abcba", "bc", "yz") = "ayzya"
StringUtil.replaceChars("abcba", "bc", "y") = "ayya"
StringUtil.replaceChars("abcba", "bc", "yzx") = "ayzya"
str 要扫描的字符串
searchChars 要搜索的字符串
replaceChars 替换字符串
被替换后的字符串,如果原始字符串为null,则返回nullpublic static String overlay(String str, String overlay, int start, int end)
null,则返回null。 负的索引值将被看作0,越界的索引值将被设置成字符串的长度相同的值。
StringUtil.overlay(null, *, *, *) = null
StringUtil.overlay("", "abc", 0, 0) = "abc"
StringUtil.overlay("abcdef", null, 2, 4) = "abef"
StringUtil.overlay("abcdef", "", 2, 4) = "abef"
StringUtil.overlay("abcdef", "", 4, 2) = "abef"
StringUtil.overlay("abcdef", "zzzz", 2, 4) = "abzzzzef"
StringUtil.overlay("abcdef", "zzzz", 4, 2) = "abzzzzef"
StringUtil.overlay("abcdef", "zzzz", -1, 4) = "zzzzef"
StringUtil.overlay("abcdef", "zzzz", 2, 8) = "abzzzz"
StringUtil.overlay("abcdef", "zzzz", -2, -3) = "zzzzabcdef"
StringUtil.overlay("abcdef", "zzzz", 8, 10) = "abcdefzzzz"
str 要扫描的字符串
overlay 用来覆盖的字符串
start 起始索引
end 结束索引
被覆盖后的字符串,如果原始字符串为null,则返回nullpublic static String chomp(String str)
\n"、"\r"、"\r\n"。
StringUtil.chomp(null) = null
StringUtil.chomp("") = ""
StringUtil.chomp("abc \r") = "abc "
StringUtil.chomp("abc\n") = "abc"
StringUtil.chomp("abc\r\n") = "abc"
StringUtil.chomp("abc\r\n\r\n") = "abc\r\n"
StringUtil.chomp("abc\n\r") = "abc\n"
StringUtil.chomp("abc\n\rabc") = "abc\n\rabc"
StringUtil.chomp("\r") = ""
StringUtil.chomp("\n") = ""
StringUtil.chomp("\r\n") = ""
str 要处理的字符串
不以换行结尾的字符串,如果原始字串为null,则返回nullpublic static String chomp(String str, String separator)
StringUtil.chomp(null, *) = null
StringUtil.chomp("", *) = ""
StringUtil.chomp("foobar", "bar") = "foo"
StringUtil.chomp("foobar", "baz") = "foobar"
StringUtil.chomp("foo", "foo") = ""
StringUtil.chomp("foo ", "foo") = "foo "
StringUtil.chomp(" foo", "foo") = " "
StringUtil.chomp("foo", "foooo") = "foo"
StringUtil.chomp("foo", "") = "foo"
StringUtil.chomp("foo", null) = "foo"
str 要处理的字符串
separator 要删除的字符串
不以指定字符串结尾的字符串,如果原始字串为null,则返回nullpublic static String chop(String str)
\r\n结尾,则同时删除它们。
StringUtil.chop(null) = null
StringUtil.chop("") = ""
StringUtil.chop("abc \r") = "abc "
StringUtil.chop("abc\n") = "abc"
StringUtil.chop("abc\r\n") = "abc"
StringUtil.chop("abc") = "ab"
StringUtil.chop("abc\nabc") = "abc\nab"
StringUtil.chop("a") = ""
StringUtil.chop("\r") = ""
StringUtil.chop("\n") = ""
StringUtil.chop("\r\n") = ""
str 要处理的字符串
删除最后一个字符的字符串,如果原始字符串为null,则返回nullpublic static String repeat(String str, int repeat)
StringUtil.repeat(null, 2) = null
StringUtil.repeat("", 0) = ""
StringUtil.repeat("", 2) = ""
StringUtil.repeat("a", 3) = "aaa"
StringUtil.repeat("ab", 2) = "abab"
StringUtil.repeat("abcd", 2) = "abcdabcd"
StringUtil.repeat("a", -2) = ""
str 要重复的字符串
repeat 重复次数,如果小于0,则看作0
重复n次的字符串,如果原始字符串为null,则返回nullpublic static String alignLeft(String str, int size)
' '填充右边。
StringUtil.alignLeft(null, *) = null
StringUtil.alignLeft("", 3) = " "
StringUtil.alignLeft("bat", 3) = "bat"
StringUtil.alignLeft("bat", 5) = "bat "
StringUtil.alignLeft("bat", 1) = "bat"
StringUtil.alignLeft("bat", -1) = "bat"
str 要对齐的字符串
size 扩展字符串到指定宽度
扩展后的字符串,如果字符串为null,则返回nullpublic static String alignLeft(String str, int size, char padChar)
StringUtil.alignLeft(null, *, *) = null
StringUtil.alignLeft("", 3, 'z') = "zzz"
StringUtil.alignLeft("bat", 3, 'z') = "bat"
StringUtil.alignLeft("bat", 5, 'z') = "batzz"
StringUtil.alignLeft("bat", 1, 'z') = "bat"
StringUtil.alignLeft("bat", -1, 'z') = "bat"
str 要对齐的字符串
size 扩展字符串到指定宽度
padChar 填充字符
扩展后的字符串,如果字符串为null,则返回nullpublic static String alignLeft(String str, int size, String padStr)
StringUtil.alignLeft(null, *, *) = null
StringUtil.alignLeft("", 3, "z") = "zzz"
StringUtil.alignLeft("bat", 3, "yz") = "bat"
StringUtil.alignLeft("bat", 5, "yz") = "batyz"
StringUtil.alignLeft("bat", 8, "yz") = "batyzyzy"
StringUtil.alignLeft("bat", 1, "yz") = "bat"
StringUtil.alignLeft("bat", -1, "yz") = "bat"
StringUtil.alignLeft("bat", 5, null) = "bat "
StringUtil.alignLeft("bat", 5, "") = "bat "
str 要对齐的字符串
size 扩展字符串到指定宽度
padStr 填充字符串
扩展后的字符串,如果字符串为null,则返回nullpublic static String alignRight(String str, int size)
' '填充左边。
StringUtil.alignRight(null, *) = null
StringUtil.alignRight("", 3) = " "
StringUtil.alignRight("bat", 3) = "bat"
StringUtil.alignRight("bat", 5) = " bat"
StringUtil.alignRight("bat", 1) = "bat"
StringUtil.alignRight("bat", -1) = "bat"
str 要对齐的字符串
size 扩展字符串到指定宽度
扩展后的字符串,如果字符串为null,则返回nullpublic static String alignRight(String str, int size, char padChar)
StringUtil.alignRight(null, *, *) = null
StringUtil.alignRight("", 3, 'z') = "zzz"
StringUtil.alignRight("bat", 3, 'z') = "bat"
StringUtil.alignRight("bat", 5, 'z') = "zzbat"
StringUtil.alignRight("bat", 1, 'z') = "bat"
StringUtil.alignRight("bat", -1, 'z') = "bat"
str 要对齐的字符串
size 扩展字符串到指定宽度
padChar 填充字符
扩展后的字符串,如果字符串为null,则返回nullpublic static String alignRight(String str, int size, String padStr)
StringUtil.alignRight(null, *, *) = null
StringUtil.alignRight("", 3, "z") = "zzz"
StringUtil.alignRight("bat", 3, "yz") = "bat"
StringUtil.alignRight("bat", 5, "yz") = "yzbat"
StringUtil.alignRight("bat", 8, "yz") = "yzyzybat"
StringUtil.alignRight("bat", 1, "yz") = "bat"
StringUtil.alignRight("bat", -1, "yz") = "bat"
StringUtil.alignRight("bat", 5, null) = " bat"
StringUtil.alignRight("bat", 5, "") = " bat"
str 要对齐的字符串
size 扩展字符串到指定宽度
padStr 填充字符串
扩展后的字符串,如果字符串为null,则返回nullpublic static String center(String str, int size)
' '填充两边。
StringUtil.center(null, *) = null
StringUtil.center("", 4) = " "
StringUtil.center("ab", -1) = "ab"
StringUtil.center("ab", 4) = " ab "
StringUtil.center("abcd", 2) = "abcd"
StringUtil.center("a", 4) = " a "
str 要对齐的字符串
size 扩展字符串到指定宽度
扩展后的字符串,如果字符串为null,则返回nullpublic static String center(String str, int size, char padChar)
StringUtil.center(null, *, *) = null
StringUtil.center("", 4, ' ') = " "
StringUtil.center("ab", -1, ' ') = "ab"
StringUtil.center("ab", 4, ' ') = " ab "
StringUtil.center("abcd", 2, ' ') = "abcd"
StringUtil.center("a", 4, ' ') = " a "
StringUtil.center("a", 4, 'y') = "yayy"
str 要对齐的字符串
size 扩展字符串到指定宽度
padChar 填充字符
扩展后的字符串,如果字符串为null,则返回nullpublic static String center(String str, int size, String padStr)
StringUtil.center(null, *, *) = null
StringUtil.center("", 4, " ") = " "
StringUtil.center("ab", -1, " ") = "ab"
StringUtil.center("ab", 4, " ") = " ab "
StringUtil.center("abcd", 2, " ") = "abcd"
StringUtil.center("a", 4, " ") = " a "
StringUtil.center("a", 4, "yz") = "yayz"
StringUtil.center("abc", 7, null) = " abc "
StringUtil.center("abc", 7, "") = " abc "
str 要对齐的字符串
size 扩展字符串到指定宽度
padStr 填充字符串
扩展后的字符串,如果字符串为null,则返回nullpublic static String reverse(String str)
null,则返回null。
StringUtil.reverse(null) = null
StringUtil.reverse("") = ""
StringUtil.reverse("bat") = "tab"
str 要反转的字符串
反转后的字符串,如果原字符串为null,则返回nullpublic static String reverseDelimited(String str, char separatorChar)
null,则返回null。
StringUtil.reverseDelimited(null, *) = null
StringUtil.reverseDelimited("", *) = ""
StringUtil.reverseDelimited("a.b.c", 'x') = "a.b.c"
StringUtil.reverseDelimited("a.b.c", '.') = "c.b.a"
str 要反转的字符串
separatorChar 分隔符
反转后的字符串,如果原字符串为null,则返回nullpublic static String reverseDelimited(String str, String separatorChars, String separator)
null,则返回null。
StringUtil.reverseDelimited(null, *, *) = null
StringUtil.reverseDelimited("", *, *) = ""
StringUtil.reverseDelimited("a.b.c", null, null) = "a.b.c"
StringUtil.reverseDelimited("a.b.c", "", null) = "a.b.c"
StringUtil.reverseDelimited("a.b.c", ".", ",") = "c,b,a"
StringUtil.reverseDelimited("a.b.c", ".", null) = "c b a"
str 要反转的字符串
separatorChars 分隔符,如果为null,则默认使用空白字符
separator 用来连接子串的分隔符,如果为null,默认使用空格
反转后的字符串,如果原字符串为null,则返回nullpublic static String abbreviate(String str, int maxWidth)
str比maxWidth短,直接返回;
substring(str, 0, max-3) + "...";
maxWidth小于4抛出IllegalArgumentException;
maxWidth。
StringUtil.abbreviate(null, *) = null
StringUtil.abbreviate("", 4) = ""
StringUtil.abbreviate("abcdefg", 6) = "abc..."
StringUtil.abbreviate("abcdefg", 7) = "abcdefg"
StringUtil.abbreviate("abcdefg", 8) = "abcdefg"
StringUtil.abbreviate("abcdefg", 4) = "a..."
StringUtil.abbreviate("abcdefg", 3) = IllegalArgumentException
str 要检查的字符串
maxWidth 最大长度,不小于4,如果小于4,则看作4
字符串缩略,如果原始字符串为null则返回nullpublic static String abbreviate(String str, int offset, int maxWidth)
abbreviate(String, int)类似,但是增加了一个“左边界”偏移量。
注意,“左边界”处的字符未必出现在结果字符串的最左边,但一定出现在结果字符串中。
返回的字符串不可能长于指定的maxWidth。
StringUtil.abbreviate(null, *, *) = null
StringUtil.abbreviate("", 0, 4) = ""
StringUtil.abbreviate("abcdefghijklmno", -1, 10) = "abcdefg..."
StringUtil.abbreviate("abcdefghijklmno", 0, 10) = "abcdefg..."
StringUtil.abbreviate("abcdefghijklmno", 1, 10) = "abcdefg..."
StringUtil.abbreviate("abcdefghijklmno", 4, 10) = "abcdefg..."
StringUtil.abbreviate("abcdefghijklmno", 5, 10) = "...fghi..."
StringUtil.abbreviate("abcdefghijklmno", 6, 10) = "...ghij..."
StringUtil.abbreviate("abcdefghijklmno", 8, 10) = "...ijklmno"
StringUtil.abbreviate("abcdefghijklmno", 10, 10) = "...ijklmno"
StringUtil.abbreviate("abcdefghijklmno", 12, 10) = "...ijklmno"
StringUtil.abbreviate("abcdefghij", 0, 3) = IllegalArgumentException
StringUtil.abbreviate("abcdefghij", 5, 6) = IllegalArgumentException
str 要检查的字符串
offset 左边界偏移量
maxWidth 最大长度,不小于4,如果小于4,则看作4
字符串缩略,如果原始字符串为null则返回nullpublic static String difference(String str1, String str2)
StringUtil.difference("i am a machine", "i am a robot") = "robot"
StringUtil.difference(null, null) = null
StringUtil.difference("", "") = ""
StringUtil.difference("", null) = ""
StringUtil.difference("", "abc") = "abc"
StringUtil.difference("abc", "") = ""
StringUtil.difference("abc", "abc") = ""
StringUtil.difference("ab", "abxyz") = "xyz"
StringUtil.difference("abcde", "abxyz") = "xyz"
StringUtil.difference("abcde", "xyz") = "xyz"
str1 字符串1
str2 字符串2
第二个字符串中,和第一个字符串不同的部分。如果两个字符串相同,则返回空字符串""public static int indexOfDifference(String str1, String str2)
StringUtil.indexOfDifference("i am a machine", "i am a robot") = 7
StringUtil.indexOfDifference(null, null) = -1
StringUtil.indexOfDifference("", null) = -1
StringUtil.indexOfDifference("", "") = -1
StringUtil.indexOfDifference("", "abc") = 0
StringUtil.indexOfDifference("abc", "") = 0
StringUtil.indexOfDifference("abc", "abc") = -1
StringUtil.indexOfDifference("ab", "abxyz") = 2
StringUtil.indexOfDifference("abcde", "abxyz") = 2
StringUtil.indexOfDifference("abcde", "xyz") = 0
str1 字符串1
str2 字符串2
两字符串开始产生差异的索引值,如果两字符串相同,则返回-1public static int getLevenshteinDistance(String s, String t)
0代表字符串相等,数字越大表示字符串越不像。
这个算法取自http://www.merriampark.com/ld.htm。
它计算的是从字符串1转变到字符串2所需要的删除、插入和替换的步骤数。
StringUtil.getLevenshteinDistance(null, *) = IllegalArgumentException
StringUtil.getLevenshteinDistance(*, null) = IllegalArgumentException
StringUtil.getLevenshteinDistance("","") = 0
StringUtil.getLevenshteinDistance("","a") = 1
StringUtil.getLevenshteinDistance("aaapppp", "") = 7
StringUtil.getLevenshteinDistance("frog", "fog") = 1
StringUtil.getLevenshteinDistance("fly", "ant") = 3
StringUtil.getLevenshteinDistance("elephant", "hippo") = 7
StringUtil.getLevenshteinDistance("hippo", "elephant") = 7
StringUtil.getLevenshteinDistance("hippo", "zzzzzzzz") = 8
StringUtil.getLevenshteinDistance("hello", "hallo") = 1
s 第一个字符串,如果是null,则看作空字符串
t 第二个字符串,如果是null,则看作空字符串
相似度值Copyright © 2018. All rights reserved.