StringUtils学习
仓库地址：https://mvnrepository.com/artifact/org.apache.commons/commons-lang3
之前从来没用过，工作后发现使用很频繁于是来学习一下
常用方法：
1：判断非空
isEmpty(final CharSequence cs)
这里有一个接口CharSequence，不了解的可以看一下 CharSequence入门学习
//检查 CharSequence 是否为空 ("") 或 null。
// StringUtils.isEmpty(null) = true
// StringUtils.isEmpty("") = true
// StringUtils.isEmpty(" ") = false
// StringUtils.isEmpty("bob") = false
// StringUtils.isEmpty(" bob ") = false
//注意：此方法在 Lang 2.0 版中有所更改。它不再修剪 CharSequence。该功能在 isBlank() 中可用。
//参数：cs – 要检查的 CharSequence，可能为 null
//return：如果 CharSequence 为空或 null，则为true
//since：3.0 将签名从 isEmpty(String) 更改为 isEmpty(CharSequence)
public static boolean isEmpty(final CharSequence cs) {
return cs == null || cs.length() == 0;
}
//取反
public static boolean isNotEmpty(final CharSequence cs) {
return !isEmpty(cs);
}
//多个有一个为空返回true，否则返回false
public static boolean isAnyEmpty(final CharSequence... css) {
if (ArrayUtils.isEmpty(css)) {
return false;
}
for (final CharSequence cs : css) {
if (isEmpty(cs)) {
return true;
}
}
return false;
}
//取反
public static boolean isNoneEmpty(final CharSequence... css) {
return !isAnyEmpty(css);
}
isBlank
//检查 CharSequence 是否为空 ("")、null 或仅空格。空白由Character.isWhitespace(char)定义。
// StringUtils.isBlank(null) = true
// StringUtils.isBlank("") = true
// StringUtils.isBlank(" ") = true
// StringUtils.isBlank("bob") = false
// StringUtils.isBlank(" bob ") = false
//参数：cs – 要检查的 CharSequence，可能为 null
//return：如果 CharSequence 为 null、空或仅空格，则为true
public static boolean isBlank(final CharSequence cs) {
final int strLen = length(cs);
if (strLen == 0) {
return true;
}
for (int i = 0; i < strLen; i++) {
if (!Character.isWhitespace(cs.charAt(i))) {
return false;
}
}
return true;
}
//取反
public static boolean isNotBlank(final CharSequence cs) {
return !isBlank(cs);
}
//多个有一个为空返回true，否则返回false
public static boolean isAnyBlank(final CharSequence... css) {
if (ArrayUtils.isEmpty(css)) {
return false;
}
for (final CharSequence cs : css) {
if (isBlank(cs)) {
return true;
}
}
return false;
}
//取反
public static boolean isNoneBlank(final CharSequence... css) {
return !isAnyBlank(css);
}
isWhitespace
//检查 CharSequence 是否仅包含空格。
//空白由Character.isWhitespace(char)定义。
//null将返回false 。一个空的 CharSequence (length()=0) 将返回true 。
// StringUtils.isWhitespace(null) = false
// StringUtils.isWhitespace("") = true
// StringUtils.isWhitespace(" ") = true
// StringUtils.isWhitespace("abc") = false
// StringUtils.isWhitespace("ab2c") = false
// StringUtils.isWhitespace("ab-c") = false
//参数：cs – 要检查的 CharSequence，可能为 null
//return：如果仅包含空格且为非 null，则为true
public static boolean isWhitespace(final CharSequence cs) {
if (cs == null) {
return false;
}
final int sz = cs.length();
for (int i = 0; i < sz; i++) {
if (!Character.isWhitespace(cs.charAt(i))) {
return false;
}
}
return true;
}
区别：
- blank：代表的是空串(“”)、空白符(空格"“，” “，制表符”\t"，回车符"\r"，"\n"等)以及null值；
- empty：代表的是空串(“”)和null值，不包含空白符；
- whitespace：包含空串(“”)和空白符，不包含null值.
示例：
StringUtils.isEmpty(null);//true
StringUtils.isEmpty("");//true
StringUtils.isEmpty(" ");//false
StringUtils.isEmpty("\t");//false
StringUtils.isEmpty("\r");//false
StringUtils.isEmpty("\n");//false
StringUtils.isBlank(null);//true
StringUtils.isBlank("");//true
StringUtils.isBlank(" ");//true
StringUtils.isBlank("\t");//true
StringUtils.isBlank("\r");//true
StringUtils.isBlank("\n");//true
StringUtils.isWhitespace(null);//false
StringUtils.isWhitespace("");//true
StringUtils.isWhitespace(" ");//true
StringUtils.isWhitespace("\t");//true
StringUtils.isWhitespace("\r");//true
StringUtils.isWhitespace("\n");//true
2.截取字符串
substring
//从指定的 String 中获取子字符串，避免异常。
//负开始位置可用于从字符串末尾开始n字符。
//null字符串将返回null 。空 ("") 字符串将返回 ""。
// StringUtils.substring(null, *) = null
// StringUtils.substring("", *) = ""
// StringUtils.substring("abc", 0) = "abc"
// StringUtils.substring("abc", 2) = "c"
// StringUtils.substring("abc", 4) = ""
// StringUtils.substring("abc", -2) = "bc"
// StringUtils.substring("abc", -4) = "abc"
//参数：str - 要从中获取子字符串的字符串，可能为 null
// start - 开始的位置，负数表示从字符串的末尾倒数这么多字符
//return：从起始位置开始的子字符串，如果为null则为 null 字符串输入
public static String substring(final String str, int start)
// 如果start不严格位于end的左侧，则返回 ""。
// StringUtils.substring(null, *, *) = null
// StringUtils.substring("", * , *) = "";
// StringUtils.substring("abc", 0, 2) = "ab"
// StringUtils.substring("abc", 2, 0) = ""
// StringUtils.substring("abc", 2, 4) = "c"
// StringUtils.substring("abc", 4, 6) = ""
// StringUtils.substring("abc", 2, 2) = ""
// StringUtils.substring("abc", -2, -1) = "b"
// StringUtils.substring("abc", -4, 2) = "ab"
//参数：str - 要从中获取子字符串的字符串，可能为 null
// start - 开始的位置，负数表示从字符串的末尾倒数这么多字符
// end – 结束的位置（不包括），负数表示从字符串的末尾倒数这么多字符
//return：从开始位置到结束位置的子字符串，如果为null则为 null 字符串输入
public static String substring(final String str, int start, int end)
substringAfter
//获取第一次出现分隔符后的子字符串。不返回分隔符。
//null字符串输入将返回null 。空 ("") 字符串输入将返回空字符串。如果输入字符串不是null ，则null分隔符将返回空字符串。
//如果没有找到，则返回空字符串。
// StringUtils.substringAfter(null, *) = null
// StringUtils.substringAfter("", *) = ""
// StringUtils.substringAfter(*, null) = ""
// StringUtils.substringAfter("abc", "a") = "bc"
// StringUtils.substringAfter("abcba", "b") = "cba"
// StringUtils.substringAfter("abc", "c") = ""
// StringUtils.substringAfter("abc", "d") = ""
// StringUtils.substringAfter("abc", "") = "abc"
//参数：str - 要从中获取子字符串的字符串，可能为 null
// separator -- 要搜索的字符串，可能为 null
//return：第一次出现分隔符后的子字符串，如果为null则为 null 字符串输入
public static String substringAfter(final String str, final String separator)
//获取最后一次出现分隔符之后的子字符串。不返回分隔符。
//null字符串输入将返回null 。空 ("") 字符串输入将返回空字符串。如果输入字符串不是null ，则空或null分隔符将返回空字符串。
//如果没有找到，则返回空字符串。
// StringUtils.substringAfterLast(null, *) = null
// StringUtils.substringAfterLast("", *) = ""
// StringUtils.substringAfterLast(*, "") = ""
// StringUtils.substringAfterLast(*, null) = ""
// StringUtils.substringAfterLast("abc", "a") = "bc"
// StringUtils.substringAfterLast("abcba", "b") = "a"
// StringUtils.substringAfterLast("abc", "c") = ""
// StringUtils.substringAfterLast("a", "a") = ""
// StringUtils.substringAfterLast("a", "z") = ""
//参数：str - 要从中获取子字符串的字符串，可能为 null
// separator -- 要搜索的字符串，可能为 null
//return：最后一次出现分隔符之后的子字符串，如果为null则为 null 字符串输入
public static String substringAfterLast(final String str, final String separator)
substringBefore
//获取第一次出现分隔符之前的子字符串。不返回分隔符。
//null字符串输入将返回null 。空 ("") 字符串输入将返回空字符串。 null分隔符将返回输入字符串。
//如果没有找到，则返回字符串输入。
// StringUtils.substringBefore(null, *) = null
// StringUtils.substringBefore("", *) = ""
// StringUtils.substringBefore("abc", "a") = ""
// StringUtils.substringBefore("abcba", "b") = "a"
// StringUtils.substringBefore("abc", "c") = "ab"
// StringUtils.substringBefore("abc", "d") = "abc"
// StringUtils.substringBefore("abc", "") = ""
// StringUtils.substringBefore("abc", null) = "abc"
//参数：str - 要从中获取子字符串的字符串，可能为 null
// separator -- 要搜索的字符串，可能为 null
//return：第一次出现分隔符之前的子字符串，如果为null则为 null 字符串输入
public static String substringBefore(final String str, final String separator)
//获取最后一次出现分隔符之前的子字符串。不返回分隔符。
//null字符串输入将返回null 。空 ("") 字符串输入将返回空字符串。空或null分隔符将返回输入字符串。
//如果没有找到，则返回字符串输入。
// StringUtils.substringBeforeLast(null, *) = null
// StringUtils.substringBeforeLast("", *) = ""
// StringUtils.substringBeforeLast("abcba", "b") = "abc"
// StringUtils.substringBeforeLast("abc", "c") = "ab"
// StringUtils.substringBeforeLast("a", "a") = ""
// StringUtils.substringBeforeLast("a", "z") = "a"
// StringUtils.substringBeforeLast("a", null) = "a"
// StringUtils.substringBeforeLast("a", "") = "a"
//参数：str - 要从中获取子字符串的字符串，可能为 null
// separator -- 要搜索的字符串，可能为 null
//return：最后一次出现分隔符之前的子字符串，如果为null则为 null 字符串输入
public static String substringBeforeLast(final String str, final String separator)
substringBetween
//获取嵌套在两个字符串之间的字符串。仅返回第一个匹配项。
//null输入字符串返回null 。 null打开/关闭返回null （不匹配）。空 ("") 打开和关闭返回一个空字符串。
// StringUtils.substringBetween("wx[b]yz", "[", "]") = "b"
// StringUtils.substringBetween(null, *, *) = null
// StringUtils.substringBetween(*, null, *) = null
// StringUtils.substringBetween(*, *, null) = null
// StringUtils.substringBetween("", "", "") = ""
// StringUtils.substringBetween("", "", "]") = null
// StringUtils.substringBetween("", "[", "]") = null
// StringUtils.substringBetween("yabcz", "", "") = ""
// StringUtils.substringBetween("yabcz", "y", "z") = "abc"
// StringUtils.substringBetween("yabczyabcz", "y", "z") = "abc"
//参数：str - 包含子字符串的字符串，可以为 null
// open – 子字符串之前的字符串，可以为 null
// close – 子字符串后面的字符串，可以为 null
//return：子字符串，如果不匹配，则为null
public static String substringBetween(final String str, final String open, final String close)
//同上
public static String substringBetween(final String str, final String tag) {
return substringBetween(str, tag, tag);
}
//在字符串中搜索由开始和结束标记分隔的子字符串，返回数组中所有匹配的子字符串。
//null输入字符串返回null 。 null打开/关闭返回null （不匹配）。空 ("") 打开/关闭返回null （不匹配）。
// StringUtils.substringsBetween("[a][b][c]", "[", "]") = ["a","b","c"]
// StringUtils.substringsBetween(null, *, *) = null
// StringUtils.substringsBetween(*, null, *) = null
// StringUtils.substringsBetween(*, *, null) = null
// StringUtils.substringsBetween("", "[", "]") = []
//参数：str - 包含子字符串的字符串，null 返回 null，empty 返回空
// open – 标识子字符串开头的字符串，空返回 null
// close – 标识子字符串结尾的字符串，空返回 null
//return：子字符串的字符串数组，如果不匹配，则为null
public static String[] substringsBetween(final String str, final String open, final String close)
3.去除空白
trim
//从此 String 的两端删除控制字符 (char <= 32)，通过返回null null
//使用String.trim()修剪字符串。 Trim 删除开始和结束字符 <= 32。要去除空格，请使用strip(String) 。
//要修剪您选择的字符，请使用strip(String, String)方法。
// StringUtils.trim(null) = null
// StringUtils.trim("") = ""
// StringUtils.trim(" ") = ""
// StringUtils.trim("abc") = "abc"
// StringUtils.trim(" abc ") = "abc"
//参数：str - 要修剪的字符串，可以为 null
//return：修剪后的字符串，如果为null则为 null 字符串输入
public static String trim(final String str) {
return str == null ? null : str.trim();
}
// StringUtils.trim(null) = ''''
// StringUtils.trim("") = ""
// StringUtils.trim(" ") = ""
// StringUtils.trim("abc") = "abc"
// StringUtils.trim(" abc ") = "abc"
public static String trimToEmpty(final String str) {
return str == null ? EMPTY : str.trim();
}
// StringUtils.trim(null) = null
// StringUtils.trim("") = null
// StringUtils.trim(" ") = null
// StringUtils.trim("abc") = "abc"
// StringUtils.trim(" abc ") = "abc"
public static String trimToNull(final String str) {
final String ts = trim(str);
return isEmpty(ts) ? null : ts;
}
strip
//从字符串的开头和结尾去除空格。
//这类似于trim(String)但删除了空格。空白由Character.isWhitespace(char)定义。
//null输入字符串返回null 。
// StringUtils.strip(null) = null
// StringUtils.strip("") = ""
// StringUtils.strip(" ") = ""
// StringUtils.strip("abc") = "abc"
// StringUtils.strip(" abc") = "abc"
// StringUtils.strip("abc ") = "abc"
// StringUtils.strip(" abc ") = "abc"
// StringUtils.strip(" ab c ") = "ab c"
//参数：str - 要从中删除空格的字符串，可能为 null
//回报：剥离的字符串，如果为null字符串输入则为空
public static String strip(final String str) {
return strip(str, null);
}
//从字符串的开头和结尾删除任何一组字符。这类似于String.trim()但允许剥离字符以进行控制。
//null输入字符串返回null 。空字符串 ("") 输入返回空字符串。
//如果 stripChars String 为null ，则按照Character.isWhitespace(char)的定义去除空格。或者使用strip(String) 。
// StringUtils.strip(null, *) = null
// StringUtils.strip("", *) = ""
// StringUtils.strip("abc", null) = "abc"
// StringUtils.strip(" abc", null) = "abc"
// StringUtils.strip("abc ", null) = "abc"
// StringUtils.strip(" abc ", null) = "abc"
// StringUtils.strip(" abcyx", "xyz") = " abc"
//参数：str - 要从中删除字符的字符串，可能为 null
// stripChars – 要删除的字符，null 被视为空格
//return：剥离的字符串，如果为null字符串输入则为空
public static String strip(String str, final String stripChars) {
if (isEmpty(str)) {
return str;
}
str = stripStart(str, stripChars);
return stripEnd(str, stripChars);
}
deleteWhitespace
//从Character.isWhitespace(char)定义的字符串中删除所有空格。
// StringUtils.deleteWhitespace(null) = null
// StringUtils.deleteWhitespace("") = ""
// StringUtils.deleteWhitespace("abc") = "abc"
// StringUtils.deleteWhitespace(" ab c ") = "abc"
//参数：str - 要从中删除空格的字符串，可能为 null
//return：不带空格的字符串，如果为null字符串输入则为空
public static String deleteWhitespace(final String str)
4.大小写转换
capitalize
//根据Character.toTitleCase(int)将第一个字符更改为标题大小写的字符串。其他字符没有改变。
// StringUtils.capitalize(null) = null
// StringUtils.capitalize("") = ""
// StringUtils.capitalize("cat") = "Cat"
// StringUtils.capitalize("cAt") = "CAt"
// StringUtils.capitalize("'cat'") = "'cat'"
public static String capitalize(final String str)
//取消大写字符串，根据Character.toLowerCase(int)将第一个字符更改为小写。其他字符没有改变。
public static String uncapitalize(final String str)
upperCase&lowerCase
StringUtils.upperCase(null)); // null
StringUtils.upperCase("china")); // CHINA (全部转为大写)
StringUtils.upperCase("china", Locale.ENGLISH)); // CHINA (按照指定规则转换为大写)
StringUtils.lowerCase(null)); // null
StringUtils.lowerCase("CHINA")); // china (全部转换为小写)
StringUtils.lowerCase("CHINA", Locale.ENGLISH)); // china (按照指定转换规则转换为小写)
swapCase
StringUtils.swapCase(null)); // null
StringUtils.swapCase("BAby")); // baBY
5.替换
replace
//替换另一个字符串中所有出现的字符串。
//传递给此方法的null引用是无操作的。
// StringUtils.replace(null, *, *) = null
// StringUtils.replace("", *, *) = ""
// StringUtils.replace("any", null, *) = "any"
// StringUtils.replace("any", *, null) = "any"
// StringUtils.replace("any", "", *) = "any"
// StringUtils.replace("aba", "a", null) = "aba"
// StringUtils.replace("aba", "a", "") = "b"
// StringUtils.replace("aba", "a", "z") = "zbz"
//参数：text – 要搜索和替换的文本，可以为 null
// searchString – 要搜索的字符串，可能为 null
// replacement – 替换它的字符串，可能为 null
//return：处理任何替换的文本，如果为null则为 null 字符串输入
public static String replace(final String text, final String searchString, final String replacement)
// replace方法指定最大替换的个数
StringUtils.replace("aabaaa", "a", "z", 0)); // aabaaa (0表示替换的个数为0，也就是不替换)
StringUtils.replace("aabaaa", "a", "z", 1)); // zabaaa (1表示最多替换1个)
StringUtils.replace("aabaaa", "a", "z", 2)); // zzbaaa (2表示最多替换2个)
StringUtils.replace("aabaaa", "a", "z", 3)); // zzbzaa (3表示最多替换3个)
StringUtils.replace("aabaaa", "a", "z", -1)); // zzbzaa (-1表示全部替换)
replaceChars
//replaceChars替换单个字符或者单个字符序列
StringUtils.replaceChars("china", 'a', 'z')); // chinz
StringUtils.replaceChars("china", "a", "z")); // chinz
replaceOnce
//replaceOnce方法只会替换一次，也就是只会替换第一个要替换的字符序列
StringUtils.replaceOnce("abaa", "a", "z"));// zbaa
overlay
//overlay(String str,String overlay,int start,int end)方法可以在指定位置进行字符序列替换，从start索引处开始(包含)到end-1索引处为止进行替换
StringUtils.overlay("abcdef", "zzzz", 2, 4)); // abzzzzef
replaceEach
//replaceEach方法,可以同时替换多个字符序列，但被替换和替换的字符序列的个数应该对应，否则会报IllegalArgumentException
StringUtils.replaceEach("china", new String[] { "ch", "a" }, new String[] { "x", "z" })); // xhinz (将ch和a分别替换为x和z)
StringUtils.replaceEach("china", null, new String[] { "x", "z" })); // china (存在null，不进行替换)
StringUtils.replaceEach("china", new String[] { "ch", "a" }, new String[] { "x", "z", "y" })); // IllegalArgumentException (被替换和替换的个数不对应)
//replaceEachRepeatedly方法,可以循环进行替换
StringUtils.replaceEachRepeatedly("china", new String[] { "c", "x" }, new String[] { "x", "z" })); // zhina (c被替换为x，x又被替换为z)
6.包含
contains
//区分大小写
StringUtils.contains(null, 'a'); // false
StringUtils.contains("china", null); // false
StringUtils.contains("", 'a'); // false
StringUtils.contains("china", 'a');// true
StringUtils.contains("china", 'z');//false
StringUtils.contains(null, "a"); // false
StringUtils.contains("china", null); // false
StringUtils.contains("", ""); // true
StringUtils.contains("abc", "");// true
StringUtils.contains("china", "na");// true
StringUtils.contains("abc", "z"); // false
//不区分大小写
StringUtils.containsIgnoreCase("china", 'a');// true
StringUtils.containsIgnoreCase("china", 'A');// true
StringUtils.containsIgnoreCase("china", 'Z');//false
StringUtils.containsIgnoreCase(null, "A"); // false
StringUtils.containsIgnoreCase("china", null); // false
StringUtils.containsIgnoreCase("", ""); // true
StringUtils.containsIgnoreCase("abc", "");// true
StringUtils.containsIgnoreCase("china", "na");// true
StringUtils.containsIgnoreCase("china", "Na");// true
StringUtils.containsIgnoreCase("abc", "Z"); // false
containsAny
//判断字符串中是否包含指定字符集合中或指定字符串中任一字符
StringUtils.containsAny(null, 'a', 'b');// false
StringUtils.containsAny("", 'a', 'b');// false
StringUtils.containsAny("abc", 'a', 'z');// true
StringUtils.containsAny("abc", 'x', 'y');// false
StringUtils.containsAny("abc", 'A', 'z');// false
StringUtils.containsAny(null, "a");// false
StringUtils.containsAny("", "a");// false
StringUtils.containsAny("abc", "ab");// true
StringUtils.containsAny("abc", "ax");// true
StringUtils.containsAny("abc", "xy");// false
StringUtils.containsAny("abc", "Ax");// false
containsNone
//判断字符串中是否不包含指定的字符或指定的字符串中的字符
StringUtils.containsNone(null, 'a'); // true
StringUtils.containsNone("", 'a'); // true 注意这里，空串总是返回true
StringUtils.containsNone("china", ' '); // true 注意包含空白符为true
StringUtils.containsNone("china", '\t'); // true
StringUtils.containsNone("china", '\r'); // true
StringUtils.containsNone("china", 'x', 'y', 'z'); // true
StringUtils.containsNone("china", 'c', 'y', 'z'); // false
StringUtils.containsNone("china", 'C', 'y', 'z'); // true
StringUtils.containsNone(null, "a"); // true
StringUtils.containsNone("", "a"); // true
StringUtils.containsNone("china", ""); // true
StringUtils.containsNone("china", "xyz"); // true
StringUtils.containsNone("china", "cyz"); // false
StringUtils.containsNone("china", "Cyz"); // true
containsOnly
//判断字符串中的字符是否都是出自所指定的字符数组或字符串
StringUtils.containsOnly(null, 'a');// false
StringUtils.containsOnly("", "a");// true
StringUtils.containsOnly("ab", ' ');// false
StringUtils.containsOnly("abab", 'a', 'b', 'c');// true
StringUtils.containsOnly("abcd", 'a', 'b', 'c');// false
StringUtils.containsOnly("Abab", 'a', 'b', 'c');// false
StringUtils.containsOnly(null, "a");// false
StringUtils.containsOnly("", "a"); // true
StringUtils.containsOnly("abab", "abc));// true
StringUtils.containsOnly("abcd", "abc"); // false
StringUtils.containsOnly("Abab", "abc");// false
startsWith
//区分大小写
StringUtils.startsWith(null, null); // true
StringUtils.startsWith(null, "abc"); // false
StringUtils.startsWith("abcdef", null); // false
StringUtils.startsWith("abcdef", "abc"); // true
StringUtils.startsWith("ABCDEF", "abc"); // false
//不区分大小写
StringUtils.startsWithIgnoreCase(null, null);// true
StringUtils.startsWithIgnoreCase(null, "abc");// false
StringUtils.startsWithIgnoreCase("abcdef", null);// false
StringUtils.startsWithIgnoreCase("abcdef", "abc");// true
StringUtils.startsWithIgnoreCase("ABCDEF", "abc");// true
startsWithAny
//判断字符串是否以指定的字符序列数组中任意一个开头
StringUtils.startsWithAny(null, null);// false
StringUtils.startsWithAny(null, new String[] { "abc" });// false
StringUtils.startsWithAny("abcxyz", null);// false
StringUtils.startsWithAny("abcxyz", new String[] { "" });// true
StringUtils.startsWithAny("abcxyz", new String[] { "abc" });// true
StringUtils.startsWithAny("abcxyz", new String[] { null, "xyz", "abc" });// true
StringUtils.startsWithAny("abcxyz", null, "xyz", "ABCX");// false
StringUtils.startsWithAny("ABCXYZ", null, "xyz", "abc");// false
7.删除
remove
//移除字符
StringUtils.remove(null, *) // null
StringUtils.remove("", *) //""
StringUtils.remove("queued", 'u') // "qeed"
StringUtils.remove("queued", 'z') //"queued"
//移除子字符串
StringUtils.remove(null, *) //null
StringUtils.remove("", *) //""
StringUtils.remove(*, null) //*
StringUtils.remove(*, "") //*
StringUtils.remove("queued", "ue") //"qd"
StringUtils.remove("queued", "zz") //"queued"
8.反转
reverse
//简单反转
StringUtils.reverse("china")); // anihc
//据指定分隔符进行反转
StringUtils.reverseDelimited("china", ',')); // china
StringUtils.reverseDelimited("cxhinxa", 'x')); // axhinxz
StringUtils.reverseDelimited("c.hin.a", '.')); // a.hin.c
StringUtils.reverseDelimited("c.hina", '.')); // hina.c
9.indexOf
//获取指定字符或字符序列在字符串中第一次出现的索引
//区分大小写
StringUtils.indexOf(null, 'a'); // -1
StringUtils.indexOf("", 'a'); // -1
StringUtils.indexOf("abca", 'a'); // 0
StringUtils.indexOf("abca", 'b'); // 1
StringUtils.indexOf("abca", 'A'); // -1
StringUtils.indexOf(null, "a"); // -1
StringUtils.indexOf("abc", null); // -1
StringUtils.indexOf("", ""); // 0
StringUtils.indexOf("", "a"); // -1 注意这里第二个参数为""时则为0
StringUtils.indexOf("abc", "a"); // 0
StringUtils.indexOf("abc", "b"); // 1
StringUtils.indexOf("abc", "ab"); // 0
StringUtils.indexOf("abc", ""); // 0
//不区分大小写
StringUtils.indexOfIgnoreCase(null, "a"); // -1
StringUtils.indexOfIgnoreCase("abc", null); // -1
StringUtils.indexOfIgnoreCase("", ""); // 0
StringUtils.indexOfIgnoreCase("", "a");// -1
StringUtils.indexOfIgnoreCase("abc", "b));// 1
StringUtils.indexOfIgnoreCase("abc", "B"); // 1
//获取字符序列在字符串中指定位置之后第一次出现的索引
//区分大小写
StringUtils.indexOf(null, "a", 2); // -1
StringUtils.indexOf("abc", null, 2); // -1
StringUtils.indexOf("", "", 0); // 0 注意此处和下一行都返回0，对比忽略大小写的情形，就有点不一样
StringUtils.indexOf("", "", 1); // 0
StringUtils.indexOf("", "", 2); // 0
StringUtils.indexOf("", "a", 0); // -1 不包括第二个参数为""的情况
StringUtils.indexOf("abac", "a", 1); // 2
StringUtils.indexOf("abcab", "ab", 2); // 3
StringUtils.indexOf("abc", "a", -1); // 0 -1被当作是0
StringUtils.indexOf("abc", "a", 2); // -1
//不区分大小写
StringUtils.indexOfIgnoreCase("", "", 0)); // 0
StringUtils.indexOfIgnoreCase("", "", 0)); // 1 与不忽略大小写的情况不同，下面也是
StringUtils.indexOfIgnoreCase("", "", 0)); //-1
StringUtils.indexOfIgnoreCase("abac", "A", 1)); // 2
StringUtils.indexOfIgnoreCase("abcab", "AB", 2)); // 3
StringUtils.indexOfIgnoreCase("abc", "B", -1)); // 1 -1被当作是0
//获取指定字符或字符序列在字符串中最后一次出现的索引
//区分大小写
StringUtils.lastIndexOf(null, 'a')); // -1
StringUtils.lastIndexOf("", 'a')); // -1
StringUtils.lastIndexOf("abccba", 'a')); // 5
StringUtils.lastIndexOf("abccba", 'z')); // -1
StringUtils.lastIndexOf(null, "a")); // -1
StringUtils.lastIndexOf("abc", null)); // -1
StringUtils.lastIndexOf("", "")); // 0
StringUtils.lastIndexOf("abc", "b")); // 1
StringUtils.lastIndexOf("abc", "ab")); // 0
StringUtils.lastIndexOf("abc", "")); // 3 返回字符串的长度
//不区分大小写
StringUtils.lastIndexOfIgnoreCase(null, "a");// -1
StringUtils.lastIndexOfIgnoreCase("abc", null);// -1
StringUtils.lastIndexOfIgnoreCase("", "");// 0
StringUtils.lastIndexOfIgnoreCase("abc", "B");// 1
StringUtils.lastIndexOfIgnoreCase("abc", "AB");// 0
StringUtils.lastIndexOfIgnoreCase("abc", "");// 3 返回字符串的长度
太多了，从大佬那里偷了一些，以后慢慢加吧
897
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
