StringUtils处理字符串类
apache stringutils常用方法
apache stringutils常用方法以下是Apache StringUtil类的一些常用方法：1. `isEmpty(CharSequence cs)`: 检查字符串是否为null或空字符串。
2. `isNotEmpty(CharSequence cs)`: 检查字符串是否不为null且不为空字符串。
3. `isBlank(CharSequence cs)`: 检查字符串是否为null、空字符串或只包含空白字符。
4. `isNotBlank(CharSequence cs)`: 检查字符串是否不为null且不为空字符串且不只包含空白字符。
5. `trim(String str)`: 去除字符串两端的空白字符。
6. `strip(String str)`: 去除字符串两端的空白字符，包括非可打印字符。
7. `truncate(String str, int maxLength)`: 将字符串截断为指定长度，并在末尾追加省略号。
8. `truncate(String str, int maxLength, String truncationIndicator)`: 将字符串截断为指定长度，并在末尾追加指定的截断标记。
9. `equals(CharSequence cs1, CharSequence cs2)`: 比较两个字符串是否相等。
10. `equalsIgnoreCase(CharSequence cs1, CharSequence cs2)`: 比较两个字符串是否相等，忽略大小写。
11. `startsWith(CharSequence str, CharSequence prefix)`: 判断字符串是否以指定的前缀开始。
12. `endsWith(CharSequence str, CharSequence suffix)`: 判断字符串是否以指定的后缀结束。
13. `substring(String str, int start)`: 获取字符串从指定位置开始的子串。
stringutils常用方法
stringutils常用方法StringUtils是一个Java工具类，用于处理字符串的常见操作，它提供了一系列常用的方法来处理字符串，使得开发人员可以轻松地操作和处理字符串。
下面是一些常见的StringUtils方法：1. 字符串为空或null判断：StringUtils.isEmpty(CharSequence cs)：判断CharSequence是否为空或null，其中CharSequence是代表字符串序列的接口。
StringUtils.isBlank(CharSequence cs)：判断CharSequence是否为空字符串、空格或null，其中CharSequence是代表字符串序列的接口。
2. 字符串连接：StringUtils.join(Object[] array, String separator)：使用指定的分隔符将数组中的元素连接成一个字符串。
StringUtils.join(Collection<?> collection, String separator)：使用指定的分隔符将集合中的元素连接成一个字符串。
3. 字符串截取：StringUtils.substring(String str, int start, int end)：截取字符串从指定位置开始到指定位置结束，其中start是起始位置，end 是结束位置。
StringUtils.substringBefore(String str, String separator)：截取字符串从开头到指定的分隔符之前的部分。
StringUtils.substringAfter(String str, String separator)：截取字符串从指定的分隔符之后到结尾的部分。
StringUtils.substringBetween(String str, String open, String close)：截取字符串从指定的开头和结尾之间的部分。
ApacheCommons--StringUtils字符串操作
ApacheCommons--StringUtils字符串操作需要包：commons-lang.jarStringUtils是字符串⼯具类，主要⽅法如下： 1、public static boolean isEmpty(CharSequence cs)：判断字符串是否为“”或者null， StringUtils.isEmpty(null) = true StringUtils.isEmpty("") = true StringUtils.isEmpty(" ") = false StringUtils.isEmpty("bob") = false StringUtils.isEmpty(" bob ") = false 2、public static boolean isNotEmpty(CharSequence cs)：判断字符串是否不为“”或者不为null StringUtils.isNotEmpty(null) = false StringUtils.isNotEmpty("") = false StringUtils.isNotEmpty(" ") = true StringUtils.isNotEmpty("bob") = true StringUtils.isNotEmpty(" bob ") = true 3、public static boolean isAnyEmpty(CharSequence... css)：任意⼀个参数为空的话，返回true，如果这些参数都不为空的话返回false StringUtils.isAnyEmpty(null) = true StringUtils.isAnyEmpty(null, "foo") = true StringUtils.isAnyEmpty("", "bar") = true StringUtils.isAnyEmpty("bob", "") = true StringUtils.isAnyEmpty(" bob ", null) = true StringUtils.isAnyEmpty(" ", "bar") = false StringUtils.isAnyEmpty("foo", "bar") = false 4、public static boolean isNoneEmpty(CharSequence... css)：任意⼀个参数是空，返回false，所有参数都不为空，返回true StringUtils.isNoneEmpty(null) = false StringUtils.isNoneEmpty(null, "foo") = false StringUtils.isNoneEmpty("", "bar") = false StringUtils.isNoneEmpty("bob", "") = false StringUtils.isNoneEmpty(" bob ", null) = false StringUtils.isNoneEmpty(" ", "bar") = true StringUtils.isNoneEmpty("foo", "bar") = true 5、public static boolean isBlank(CharSequence cs)：判断字符对象是不是空字符串 StringUtils.isBlank(null) = true StringUtils.isBlank("") = true StringUtils.isBlank(" ") = true StringUtils.isBlank("bob") = false StringUtils.isBlank(" bob ") = false 6、public static boolean isNotBlank(CharSequence cs)：判断字符对象是不是不为空字符串 7、public static boolean isAnyBlank(CharSequence... css)：判断字符串是不是空字符串，都是空字符串就返回true，否则返回false 8、public static boolean isNoneBlank(CharSequence... css)：判断字符串是不是不是空字符串，全部不是空字符串就返回true，否则返回false 9、public static String trim(String str)：去除字符串⾸尾的空格 10、public static boolean equals(CharSequence cs1, CharSequence cs2)：判断字符串是否相等 11、public static boolean equalsIgnoreCase(CharSequence str1, CharSequence str2)：字符串⽐较，忽略⼤⼩写 12、public static int indexOf(CharSequence seq, int searchChar)：返回字符串⾸次出现的位置索引 13、public static int ordinalIndexOf(CharSequence str, CharSequence searchStr, int ordinal)：判断字符串在另⼀个字符串第⼏次出现的位置索引 14、public static int lastIndexOf(CharSequence seq,int searchChar)：字符在字符串中最后⼀次出现的位置索引 15、public static int lastOrdinalIndexOf(CharSequence str,CharSequence searchStr, int ordinal)：判断字符在字符串倒数第⼏次出现的位置索引 16、public static boolean contains(CharSequence seq, int searchChar)：判断是字符是否在另⼀个字符串中 17、public static String substring(String str,int start)：字符串截取 18、public static String left(String str,int len)：字符串左边的多少个字符 public static String right(String str, int len)：字符串右边的多少个字符。
stringutils使用
stringutils使用StringUtils是一个Java语言的常用工具类，它提供了一系列对字符串操作的方法，能够简化字符串处理的过程。
本文将介绍StringUtils的使用方法和常见应用场景。
StringUtils类位于ng3包中，所以在使用StringUtils之前，需要先导入该包。
导入方式如下：```import ng3.StringUtils;```接下来，我们将逐个介绍StringUtils提供的常用方法及其使用。
1. 判断字符串是否为空或长度为0```StringUtils.isEmpty(str)```该方法用于判断字符串是否为null或长度为0，如果是，则返回true；否则返回false。
2. 判断字符串是否为空或只包含空格```StringUtils.isBlank(str)```该方法用于判断字符串是否为null、长度为0或只包含空格，如果是，则返回true；否则返回false。
3. 判断字符串是否不为空且长度不为0```StringUtils.isNotEmpty(str)```该方法用于判断字符串是否不为null且长度不为0，如果是，则返回true；否则返回false。
4. 判断字符串是否不为空且不只包含空格```StringUtils.isNotBlank(str)```该方法用于判断字符串是否不为null且长度不为0且不只包含空格，如果是，则返回true；否则返回false。
5. 字符串大小写转换```StringUtils.upperCase(str)StringUtils.lowerCase(str)```这两个方法分别用于将字符串转换为大写和小写。
6. 字符串截取```StringUtils.substring(str, start, end)```该方法用于截取字符串的一部分，其中start表示起始位置（包括），end表示结束位置（不包括）。
7. 字符串连接```StringUtils.join(array, separator)```该方法用于将数组中的元素用指定的分隔符连接成一个字符串。
StringUtils工具类常用方法汇总2（截取、去除空白、包含、查询索引）
StringUtils⼯具类常⽤⽅法汇总2（截取、去除空⽩、包含、查询索引） 在上⼀篇中总结了StringUtils⼯具类在判断字符串为空，⼤⼩写转换，移除字符或字符序列，替换，反转，切割合并等⽅⾯的⽅法，这次再汇总⼀下其它常⽤的⽅法。
⼀、截取 StringUtils中常⽤的截取字符串的⽅法如下：substring(String str,int start)substring(String str,int start, int end)substringAfter(String str,String separator)substringAfterLast(String str,String separator)substringBefore(String str,String separator)substringBeforeLast(String str,String separator)substringBetween(String str,String tag) 需要注意的是，截取字符串时，若被截取的字符串为null或""，则截取之后的返回的字符串也为null和""。
（1）根据指定位置截取字符串，当指定的截取位置为⾮负数时，则从左往右开始截取，第⼀位为0，后⾯依次类推，但当索引值为负数时，则从右往左截取，注意此时右侧第⼀位为-1： a）只指定了起始位置，则截取⾄字符串末尾：StringUtils.substring(null, 2); // "" null和""截取后都返回null和""StringUtils.substring(null, 2); // nullStringUtils.substring("china", 0); // china 指定的起始截取位置为0，则从第⼀位开始截取，也就是不截取StringUtils.substring("china", 2); // ina 指定的截取位置为2，则从左往右第三位开始截取StringUtils.substring("china", -2); // na 指定的截取位置为-2，则从右往左第⼆位开始截取 b）指定了起始位置和结束位置，则从起始位置开始截取到结束位置（但不包含结束位置）：StringUtils.substring(null, 2, 4); // null null和""截取后都返回null和""StringUtils.substring("", 2, 4); // ""StringUtils.substring("china", 0, 0); // ""StringUtils.substring("china", 2, 4); // inStringUtils.substring("china", -2, -4); // inStringUtils.substring("china", 2, -3); // ""StringUtils.substring("china", 2, -1); // in （2）根据指定的分隔符进⾏截取（不包含该分隔符）： a）从分隔符第⼀次出现的位置向后截取：StringUtils.substringAfter("china", "i"); // na 从第⼀次出现"i"的位置向后截取，不包含第⼀次出现的"i"StringUtils.substringAfter("china", "hi"); // naStringUtils.substringAfter("chinachina","h")); // inachinaStringUtils.substringAfter("china", "a"); // ""StringUtils.substringAfter("china", "d"); // "" 分隔符在要截取的字符串中不存在，则返回""StringUtils.substringAfter("china", "")); // china 分隔符为""，则返回原字符串Stringtils.substringAfter("china", null); // "" 分隔符为null，则返回"" b）从分隔符最后⼀次出现的位置向后截取：StringUtils.substringAfterLast("china", "i"); // naStringUtils.substringAfterLast("chinachina", "i"); // na "i"最后出现的位置向后截取 c）从分隔符第⼀次出现的位置向前截取：StringUtils.substringBefore("china", "i"); // chStringUtils.substringBefore("chinachina", "i"); // ch 从"i"第⼀次出现的位置向前截取 d）从分隔符最后⼀次出现的位置向前截取：StringUtils.substringBeforeLast("china", "i");StringUtils.substringBeforeLast("chinachina", "i"); // chinach e）截取指定标记字符串之间的字符序列：StringUtils.substringBetween(null, "ch") // nullStringUtils.substringBetween("", "") // ""StringUtils.substringBetween("tagabctag", "") // "" 标记字符串为""，则截取后返回""StringUtils.substringBetween("", "tag") // null // 注意此处返回的是nullStringUtils.substringBetween("tagabctag", null) // null 标记字符串为null，则截取后返回nullStringUtils.substringBetween("tagabctag", "tag") // "abc"⼆、去除空⽩： 去除字符串中的空⽩符是我们在处理字符串时经常遇到的问题，StringUtils中也封装了⼀些⾮常好⽤的⽅法来帮助我们解决这个问题：trim(String str)trimToEmpty(String str)trimToNull(String str)strip(String str)stripToEmpty(String str)stripToNull(String str)deleteWhitespace(String str) （1）去除字符串⾸尾的控制符（char ≤ 32） a）trim(String str)：如果被去除的字符串的为null或""，则返回null和"":StringUtils.trim(null); // nullStringUtils.trim(""); // ""StringUtils.trim(" ");// ""StringUtils.trim("abc"); // abcStringUtils.trim(" abc "); // abcStringUtils.trim(" a b c "); // "a b c" 注意此处字符串内部的控制符是不去除的 b）trimToEmpty(String str)：如果被去除的字符串的为null或""，则都返回"":StringUtils.trimToEmpty(null); // "" 此处返回的是""StringUtils.trimToEmpty(""); // ""StringUtils.trimToEmpty(" ");// ""StringUtils.trimToEmpty("abc"); // abcStringUtils.trimToEmpty(" abc "); // abcStringUtils.trimToEmpty(" a b c "); // a b c c）trimToNull(String str)：如果被去除的字符串的为null或""，则都返回null:StringUtils.trimToNull(null); // nullStringUtils.trimToNull(""); // nullStringUtils.trimToNull(" ");// nullStringUtils.trimToNull("abc"); // abcStringUtils.trimToNull(" \t\r\nabc "); // abcStringUtils.trimToNull(" a b c "); // "a b c" （2）去除字符串⾸尾的空⽩符(空⽩符主要包括' '，'\t'，'\r'，'\n'等等，具体的空⽩符可以参考Java API中Character类中isWhiteSpace()⽅法中的描述)： a）trim(String str)：如果被去除的字符串的为null或""，则返回null和"":StringUtils.strip(null); // nullStringUtils.strip(""); // ""StringUtils.strip(" ");// ""StringUtils.strip("abc"); // abcStringUtils.strip(" \t\r\n abc "); // abcStringUtils.strip(" a b c "); // a b c b）trimToEmpty(String str)：如果被去除的字符串的为null或""，则都返回"":StringUtils.stripToEmpty(null); // nullStringUtils.stripToEmpty(""); // nulldStringUtils.stripToEmpty(" ");// nullStringUtils.stripToEmpty("abc"); // abcStringUtils.stripToEmpty(" \t\r\n abc "); // abcStringUtils.stripToEmpty(" a b c "); // "a b c" c）trimToNull(String str)：如果被去除的字符串的为null或""，则都返回null:StringUtils.stripToNull(null); // nullStringUtils.stripToNull(""); // nulldStringUtils.stripToNull(" ");// nullStringUtils.stripToNull("abc"); // abcStringUtils.stripToNull(" \t\r\n abc "); // abcStringUtils.stripToNull(" a b c "); // "a b c" （2）去除字符串中所有的空⽩符：StringUtils.deleteWhitespace(null); // nullStringUtils.deleteWhitespace(""); // ""StringUtils.deleteWhitespace("abc"); // "abc"StringUtils.deleteWhitespace(" ab c "); // "abc"三、包含： StringUtils中判断是否包含的⽅法主要有：contains(CharSequence seq, int searchChar)contains(CharSequence seq, CharSequence searchSeq)containsIgnoreCase(CharSequence str, CharSequence searchStr)containsAny(CharSequence cs, char... searchChars)containsAny(CharSequence cs, CharSequence searchChars)containsOnly(CharSequence cs,char… valid)containsOnly(CharSequence cs, String validChars)containsNone(CharSequence cs,char… searchChars)containsNone(CharSequence cs, String invalidChars)startsWith(CharSequence str,CharSequence prefix)startsWithIgnoreCase(CharSequence str,CharSequence prefix)startsWithAny(CharSequence string,CharSequence… searchStrings) （1）判断字符串中是否包含指定的字符或字符序列： a）区分⼤⼩写：StringUtils.contains(null, 'a'); // falseStringUtils.contains("china", null); // falseStringUtils.contains("", 'a'); // falseStringUtils.contains("china", 'a');// trueStringUtils.contains("china", 'z');//falseStringUtils.contains(null, "a"); // falseStringUtils.contains("china", null); // falseStringUtils.contains("", ""); // trueStringUtils.contains("abc", "");// trueStringUtils.contains("china", "na");// trueStringUtils.contains("abc", "z"); // false b）不区分⼤⼩写：StringUtils.containsIgnoreCase("china", 'a');// trueStringUtils.containsIgnoreCase("china", 'A');// trueStringUtils.containsIgnoreCase("china", 'Z');//falseStringUtils.containsIgnoreCase(null, "A"); // falseStringUtils.containsIgnoreCase("china", null); // falseStringUtils.containsIgnoreCase("", ""); // trueStringUtils.containsIgnoreCase("abc", "");// trueStringUtils.containsIgnoreCase("china", "na");// trueStringUtils.containsIgnoreCase("china", "Na");// trueStringUtils.containsIgnoreCase("abc", "Z"); // false （2）判断字符串中是否包含指定字符集合中或指定字符串中任⼀字符，区分⼤⼩写：StringUtils.containsAny(null, 'a', 'b');// falseStringUtils.containsAny("", 'a', 'b');// falseStringUtils.containsAny("abc", 'a', 'z');// trueStringUtils.containsAny("abc", 'x', 'y');// falseStringUtils.containsAny("abc", 'A', 'z');// falseStringUtils.containsAny(null, "a");// falseStringUtils.containsAny("", "a");// falseStringUtils.containsAny("abc", "ab");// trueStringUtils.containsAny("abc", "ax");// trueStringUtils.containsAny("abc", "xy");// falseStringUtils.containsAny("abc", "Ax");// false （3）判断字符串中是否不包含指定的字符或指定的字符串中的字符，区分⼤⼩写：StringUtils.containsNone(null, 'a'); // trueStringUtils.containsNone("", 'a'); // true 注意这⾥，空串总是返回trueStringUtils.containsNone("china", ' '); // true 注意包含空⽩符为trueStringUtils.containsNone("china", '\t'); // trueStringUtils.containsNone("china", '\r'); // trueStringUtils.containsNone("china", 'x', 'y', 'z'); // trueStringUtils.containsNone("china", 'c', 'y', 'z'); // falseStringUtils.containsNone("china", 'C', 'y', 'z'); // trueStringUtils.containsNone(null, "a"); // trueStringUtils.containsNone("", "a"); // trueStringUtils.containsNone("china", ""); // trueStringUtils.containsNone("china", "xyz"); // trueStringUtils.containsNone("china", "cyz"); // falseStringUtils.containsNone("china", "Cyz"); // true （4）判断字符串中的字符是否都是出⾃所指定的字符数组或字符串，区分⼤⼩写：StringUtils.containsOnly(null, 'a');// falseStringUtils.containsOnly("", "a");// trueStringUtils.containsOnly("ab", ' ');// falseStringUtils.containsOnly("abab", 'a', 'b', 'c');// trueStringUtils.containsOnly("abcd", 'a', 'b', 'c');// falseStringUtils.containsOnly("Abab", 'a', 'b', 'c');// falseStringUtils.containsOnly(null, "a");// falseStringUtils.containsOnly("", "a"); // trueStringUtils.containsOnly("abab", "abc));// trueStringUtils.containsOnly("abcd", "abc"); // falseStringUtils.containsOnly("Abab", "abc");// false （5）判断字符串是否以指定的字符序列开头： a）区分⼤⼩写：StringUtils.startsWith(null, null); // trueStringUtils.startsWith(null, "abc"); // falseStringUtils.startsWith("abcdef", null); // falseStringUtils.startsWith("abcdef", "abc"); // trueStringUtils.startsWith("ABCDEF", "abc"); // false b）不区分⼤⼩写：StringUtils.startsWithIgnoreCase(null, null);// trueStringUtils.startsWithIgnoreCase(null, "abc");// falseStringUtils.startsWithIgnoreCase("abcdef", null);// falseStringUtils.startsWithIgnoreCase("abcdef", "abc");// trueStringUtils.startsWithIgnoreCase("ABCDEF", "abc");// true （6）判断字符串是否以指定的字符序列数组中任意⼀个开头，区分⼤⼩写：StringUtils.startsWithAny(null, null);// falseStringUtils.startsWithAny(null, new String[] { "abc" });// falseStringUtils.startsWithAny("abcxyz", null);// falseStringUtils.startsWithAny("abcxyz", new String[] { "" });// trueStringUtils.startsWithAny("abcxyz", new String[] { "abc" });// trueStringUtils.startsWithAny("abcxyz", new String[] { null, "xyz", "abc" });// trueStringUtils.startsWithAny("abcxyz", null, "xyz", "ABCX");// falseStringUtils.startsWithAny("ABCXYZ", null, "xyz", "abc");// false四、查询索引： StringUtils中获取字符或字符序列在字符串中出现的索引下标的⽅法主要有：indexOf(CharSequence seq, int searchChar)indexOf(CharSequence seq,CharSequence searchSeq)indexOfIgnoreCaseindexOf(CharSequence seq,CharSequence searchSeq,int startPos)lastIndexOf(CharSequence seq,int searchChar)lastIndexOfIgnoreCase(CharSequence str,CharSequence searchStr) （1）获取指定字符或字符序列在字符串中第⼀次出现的索引，若字符串中不包含该字符或字符序列，则返回-1，若字符串或字符序列为""或null，也返回-1（（但字符串和字符序列都为""的情况下，则返回0））： a）区分⼤⼩写：StringUtils.indexOf(null, 'a');// -1StringUtils.indexOf("", 'a');// -1StringUtils.indexOf("abca", 'a');// 0StringUtils.indexOf("abca", 'b');// 1StringUtils.indexOf("abca", 'A');// -1StringUtils.indexOf(null, "a"); // -1StringUtils.indexOf("abc", null); // -1StringUtils.indexOf("", ""); // 0StringUtils.indexOf("", "a"); // -1 注意这⾥第⼆个参数为""时则为0StringUtils.indexOf("abc", "a"); // 0StringUtils.indexOf("abc", "b"); // 1StringUtils.indexOf("abc", "ab"); // 0StringUtils.indexOf("abc", ""); // 0 b）不区分⼤⼩写：StringUtils.indexOfIgnoreCase(null, "a"); // -1StringUtils.indexOfIgnoreCase("abc", null); // -1StringUtils.indexOfIgnoreCase("", ""); // 0StringUtils.indexOfIgnoreCase("", "a");// -1StringUtils.indexOfIgnoreCase("abc", "b));// 1StringUtils.indexOfIgnoreCase("abc", "B"); // 1 （1）获取字符序列在字符串中指定位置之后第⼀次出现的索引，若字符串中指定位置之后不包含该字符序列，则返回-1，若字符串或字符序列为""或null，也返回-1（但字符串和字符序列都为""的情况下，结果就有点怪异，有时返回0，有时返回1，有时返回-1，根据指定的起始位置会有变化）： a）区分⼤⼩写：StringUtils.indexOf(null, "a", 2); // -1StringUtils.indexOf("abc", null, 2); // -1StringUtils.indexOf("", "", 0); // 0 注意此处和下⼀⾏都返回0，对⽐忽略⼤⼩写的情形，就有点不⼀样StringUtils.indexOf("", "", 1); // 0StringUtils.indexOf("", "", 2); // 0StringUtils.indexOf("", "a", 0); // -1 不包括第⼆个参数为""的情况StringUtils.indexOf("abac", "a", 1); // 2StringUtils.indexOf("abcab", "ab", 2); // 3StringUtils.indexOf("abc", "a", -1); // 0 -1被当作是0StringUtils.indexOf("abc", "a", 2); // -1 b）不区分⼤⼩写：StringUtils.indexOfIgnoreCase("", "", 0)); // 0StringUtils.indexOfIgnoreCase("", "", 0)); // 1 与不忽略⼤⼩写的情况不同，下⾯也是StringUtils.indexOfIgnoreCase("", "", 0)); //-1StringUtils.indexOfIgnoreCase("abac", "A", 1)); // 2StringUtils.indexOfIgnoreCase("abcab", "AB", 2)); // 3StringUtils.indexOfIgnoreCase("abc", "B", -1)); // 1 -1被当作是0 （2）获取指定字符或字符序列在字符串中最后⼀次出现的索引，若字符串中不包含该字符序列，则返回-1，若字符串或字符序列为""或null，也返回-1（但字符串和字符序列都为""的情况下，返回0）： a）区分⼤⼩写：stIndexOf(null, 'a'));// -1stIndexOf("", 'a'));// -1stIndexOf("abccba", 'a'));// 5stIndexOf("abccba", 'z'));// -1stIndexOf(null, "a"));// -1stIndexOf("abc", null));// -1stIndexOf("", ""));// 0stIndexOf("abc", "b"));// 1stIndexOf("abc", "ab"));// 0stIndexOf("abc", ""));// 3 返回字符串的长度 b）不区分⼤⼩写：stIndexOfIgnoreCase(null, "a");// -1stIndexOfIgnoreCase("abc", null);// -1stIndexOfIgnoreCase("", "");// 0stIndexOfIgnoreCase("abc", "B");// 1stIndexOfIgnoreCase("abc", "AB");// 0stIndexOfIgnoreCase("abc", "");// 3 返回字符串的长度。
stringutils 正则提取
stringutils 正则提取使用StringUtils正则提取字符串的方法在Java编程中，有时需要从一个字符串中提取特定的信息。
StringUtils是一个常用的工具类，它提供了各种方法来处理字符串。
其中，正则表达式是一个强大的工具，可以用来匹配和提取字符串中的特定模式。
本文将介绍如何使用StringUtils和正则表达式来提取字符串中的特定内容。
我们将通过一些示例来演示如何使用这些方法。
我们需要导入StringUtils类。
在使用StringUtils类之前，我们需要确保它已经被正确导入。
一、提取电话号码假设我们有一个字符串，其中包含了一些电话号码。
我们想要提取这些电话号码并进行处理。
使用StringUtils的正则表达式方法，我们可以轻松地实现这个目标。
```javaString input = "我的电话号码是：123-456-7890，你的电话号码是：987-654-3210。
";String regex = "\\d{3}-\\d{3}-\\d{4}";List<String> phoneNumbers = StringUtils.extractAll(input,regex);for (String phoneNumber : phoneNumbers) {System.out.println(phoneNumber);}```上述代码中，我们使用了一个正则表达式来匹配电话号码的格式。
其中，\\d表示数字，{3}表示连续出现3次。
通过调用StringUtils的extractAll方法，我们可以提取出所有匹配的电话号码。
二、提取邮箱地址与提取电话号码类似，我们也可以使用StringUtils和正则表达式来提取字符串中的邮箱地址。
```javaString input = "我的邮箱地址是：***************，你的邮箱地址是：***************。
stringutils中的format方法
stringutils中的format方法StringUtils中的format方法介绍在Java开发中，字符串的格式化是一种常见的操作。
StringUtils类是Apache Commons Lang库中的一个实用工具类，它提供了许多方便的方法来处理字符串。
其中的format方法是一个非常强大和常用的方法，用于格式化字符串的输出。
方法一：format(String template, Object… args)这是StringUtils中最常用的format方法，它接受一个模板字符串和一个可变参数列表。
模板字符串中含有占位符”%s”，用于表示需要被替换的位置。
该方法会将模板字符串中的占位符替换成传入的参数值，并返回替换后的字符串。
使用示例：String name = "Alice";int age = 25;String message = ("My name is %s and I am %d years old.", name, age);(message);输出结果：My name is Alice and I am 25 years old.方法二：format(String template, Map<String, Object> args)除了使用可变参数列表，format方法还支持使用Map类型的参数来进行字符串格式化。
通过传入一个Map对象，键值对的形式为模板中的占位符提供参数值。
使用示例：Map<String, Object> params = new HashMap<>(); ("name", "Bob");("age", 30);String message = ("My name is %(name)s and I am %(age)d years old.", params);(message);输出结果：My name is Bob and I am 30 years old.方法三：format(String template, Object arg, String defaultValue)该方法与方法一相似，但在未传入参数值的情况下提供了默认值的功能。
stringutils join用法
stringutils join用法StringUtils类是Apache Commons Lang库中的一个工具类，用于处理字符串的一些常见操作。
其中的join方法是一个非常有用的字符串拼接方法，在本文中，我们将详细介绍StringUtils的join方法的用法。
StringUtils类的join方法有多个重载形式，可以满足不同的需求。
该方法的基本用法是将一个字符串数组或集合中的元素通过指定的分隔符拼接成一个字符串。
具体的用法如下：```StringUtils.join(Object[] array, String separator)```这个重载形式接收一个对象数组和一个分隔符作为参数，返回拼接后的字符串。
示例代码如下：```javaString[] array = {"apple", "banana", "cherry"};String separator = "-";String result = StringUtils.join(array, separator);System.out.println(result);```这段代码的输出结果是：```apple-banana-cherry```在这个例子中，我们定义了一个字符串数组`array`，包含了三个元素。
然后我们指定了一个分隔符`separator`，这里我们使用了连字符。
最后调用StringUtils的join方法将数组中的元素用分隔符拼接成一个字符串，并将结果打印出来。
除了接收一个对象数组和一个分隔符的参数形式外，StringUtils的join方法还接收其他的参数形式，下面我们将逐一介绍这些参数形式的用法。
## 接收一个集合和指定分隔符的join方法StringUtils的join方法还有一个重载形式，可以接收一个集合作为参数，以及一个指定的分隔符字符串。
stringutils判断多个字符串不为空的封装方法
stringutils判断多个字符串不为空的封装方法一、问题背景在软件开发中，我们经常需要处理多个字符串，尤其是在进行数据验证、输出展示等方面。
有时候，我们需要确保这些字符串不为空，否则可能会引发异常或导致程序崩溃。
因此，我们需要一种简单有效的方法来判断多个字符串是否都不为空。
二、解决方案为了解决这个问题，我们可以使用Java中的String类提供的isEmpty或isBlank方法，但这些方法只能判断单个字符串是否为空或为空字符串。
为了解决多个字符串同时都不为空的情况，我们可以封装一个工具类，实现一个判断多个字符串都不为空的方法。
以下是一个简单的封装方法示例：```javapublic static void main(String[] args) {// 测试用例String[] strings = {"", null, "abc", "", "", "def", null};boolean[] results = new boolean[strings.length];StringUtils.notEmpty(strings, results);for (boolean result : results) {if (result) {System.out.println("该字符串不为空");} else {System.out.println("该字符串为空");}}}```这个方法将接收一个字符串数组和一个布尔数组作为参数，将每个字符串与对应的布尔数组元素进行比较。
如果字符串不为空，则布尔数组对应位置的元素为true；否则为false。
这样我们就可以通过检查布尔数组的长度来判断是否有任何字符串为空。
三、实现细节StringUtils类可以很好地实现这个方法，具体的实现细节如下：* 定义一个公共工具类或静态内部类。
stringutils.substring使用方法
stringutils.substring使用方法在编程中，经常需要对字符串进行截取操作，以获取所需的部分字符串。
而Apache Commons Lang库中的StringUtils类提供了一个非常方便的方法：substring()。
本文将详细介绍使用StringUtils.substring()方法的使用方法，并给出一些示例说明。
一、StringUtils.substring()方法概述：StringUtils.substring()方法用于从一个字符串中截取指定位置的子字符串。
该方法有多种重载形式，可以根据具体的需求选择合适的使用方式。
下面将分别介绍不同的参数形式。
1.1 字符串和起始位置参数形式：substring(String str, int start)：从字符串str中的起始位置为start的字符开始截取到字符串末尾，并将截取到的子字符串返回。
假设有一个字符串str = "Hello, World!"，我们想要截取出字符串中的"World!"部分，可以使用以下代码：String result = StringUtils.substring(str, 7);1.2 字符串、起始位置和结束位置参数形式：substring(String str, int start, int end)：从字符串str中的起始位置为start的字符开始截取，一直到结束位置为end的前一个字符，并将截取到的子字符串返回。
假设有一个字符串str = "Hello, World!"，我们想要截取出字符串中的"World"部分（不包含末尾的感叹号），可以使用以下代码：String result = StringUtils.substring(str, 7, 12);1.3 起始位置和长度参数形式：substring(String str, int start, int length)：从字符串str中的起始位置为start的字符开始，截取指定长度为length的子字符串，并将截取到的子字符串返回。
stringutils比较方法
stringutils比较方法StringUtils是Java中一个常用的字符串处理工具类，其中包含了许多常用的字符串操作方法，如字符串比较方法。
在实际开发中，字符串比较是非常常见的操作，因此StringUtils提供了多种字符串比较方法，以满足不同场景下的需求。
1. equals方法equals方法是Java中最基本的字符串比较方法，用于比较两个字符串是否相等。
StringUtils中的equals方法与String类中的equals方法功能相同，都是比较两个字符串是否相等。
其方法签名如下：public static boolean equals(CharSequence cs1, CharSequence cs2)其中，cs1和cs2分别表示要比较的两个字符串，返回值为boolean类型，表示两个字符串是否相等。
该方法的实现方式与String类中的equals方法类似，都是通过比较两个字符串的字符序列是否相等来判断两个字符串是否相等。
2. equalsIgnoreCase方法equalsIgnoreCase方法也是用于比较两个字符串是否相等，但是与equals方法不同的是，equalsIgnoreCase方法在比较字符串时忽略大小写。
其方法签名如下：public static boolean equalsIgnoreCase(CharSequence str1, CharSequence str2)其中，str1和str2分别表示要比较的两个字符串，返回值为boolean类型，表示两个字符串是否相等。
该方法的实现方式与equals方法类似，只是在比较字符串时忽略了大小写。
3. compare方法compare方法用于比较两个字符串的大小关系，其方法签名如下：public static int compare(String str1, String str2)其中，str1和str2分别表示要比较的两个字符串，返回值为int类型，表示两个字符串的大小关系。
StringUtils字符串工具类左侧补齐（leftPad）、右侧补齐（rightPad）。。。
StringUtils字符串⼯具类左侧补齐（leftPad）、右侧补齐（rightPad）。
这⾥使⽤的是ng.StringUtils;下⾯是StringUtils⼯具类中字符串左侧补齐的⽅法，⽰例如下：//左侧补齐第⼀个参数：原始字符串，第⼆个参数：字符串的长度，第三个是补充的字符串String newStr1 = StringUtils.leftPad("oldStr1", 10, "*");System.err.println(newStr1);//***oldStr1//获取字符串左侧指定长度的字符串，第⼀个参数：原字符串，第⼆个参数：取左侧字符串的长度String newStr2 = StringUtils.left("oldStr3", 5);System.err.println(newStr2);//oldSt//左侧补齐，默认使⽤空格补齐，第⼀个参数：原字符串，第⼆个参数：字符串总长度，不⾜⽤空格补全String newStr3 = StringUtils.leftPad("oldStr4", 10);System.err.println(newStr3);// oldStr4//左侧补齐第⼀个参数：原始字符串，第⼆个参数：字符串的长度，第三个是补充的字符串String newStr4 = StringUtils.center("oldStr1", 10, "*");System.err.println(newStr4);//*oldStr1**与上⾯的StringUtils⼯具类中字符串左侧补齐对应的还有右补齐rightPad、和center左右补齐⽅法，具体使⽤⽅法跟上⾯类似。
StringUtil字符串等相关操作
StringUtil字符串等相关操作md5(Stringsrc):byte[]获取指定字符串的MD5摘要代码实例Stringsrc="泽元";byte[]b=StringUtil.md5(src);b为：[-77,-63,-45,-59,-80,-48,44,-40,13,86,14,-41,21 ,-128,85,-43]md5(byte[]src):byte[]获取指定二进制数组的MD5摘要代码实例byte[]b="泽元".getBytes();byte[]b_1=StringUtil.md5(b);b_1为：[-77,-63,-45,-59,-80,-48,44,-40,13,86,14,-41,21 ,-128,85,-43]md5Hex(Stringsrc):String将字符串进行md5摘要，然后输出成十六进制形式代码实例Stringsrc="泽元";Stringsrc_H=StringUtil.md5Hex(src);src_H为：b3c1d3c5b0d02cd80d560ed7158055d5sha1Hex(Stringsrc):String将字符串进行sh1摘要，然后输出成十六进制形式代码实例Stringsrc="泽元";Stringsrc_sH=StringUtil.sha1Hex(src);src_sH为：dee294e58b334db34ff3be2583eb1790babfb353md5Base64(Stringstr):String将字符串进行MD5摘要，输出成BASE64形式代码实例Stringsrc="泽元";Stringsrc_64=StringUtil.md5Base64(src);src_64为：s8HTxbDQLNgNVg7XFYBV1Q==md5Base64FromHex(Stringmd5str):String将十六制进表示MD5摘要转换成BASE64格式代码实例Stringsrc_64FH=StringUtil.md5Base64FromHex(src_H);参数src_H为：b3c1d3c5b0d02cd80d560ed7158055d5src_64FH为：s8HTxbDQLNgNVg7XFYBV1Q==md5HexFromBase64(Stringbase64str):String将十六制进表示MD5摘要转换成BASE64格式代码实例Stringsrc_HF64=StringUtil.md5Base64FromHex(src_64);参数src_64为：s8HTxbDQLNgNVg7XFYBV1Q==src_HF64为：b3c1d3c5b0d02cd80d560ed7158055d5hexEncode(byte[]data):String将二进制数组转换成十六进制表示代码实例byte[]data="泽元迅长".getBytes();Stringdata_H=StringUtil.hexEncode(data);data_H为：e6b3bde58583e8bf85e995bfhexDecode(Stringstr):byte[]（尚未完成）将字符串转换成十六进制表示代码实例（尚有问题）byte[]da=StringUtil.hexDecode("泽元迅长"); byteToBin(byte[]bs):String将字节数组转换成二制形式字符串代码实例byte[]bs="泽元".getBytes();Stringbs_1=StringUtil.byteToBin(bs);bs_1为：11100110,10110011,10111101,11100101,10000101,10 000011,byteArrayToHexString(byte[]b):String转换字节数组为十六进制字串代码实例byte[]bs="泽元".getBytes();Stringbs_64=StringUtil.byteArrayToHexString(bs) ;bs_64为：e6b3bde58583isUTF8(byte[]bs):boolean判断指定的二进制数组是否是一个UTF-8字符串代码实例byte[]bs="泽元".getBytes();boolean bs_1=StringUtil.isUTF8(bs);//truebase64Encode(byte[]b):String返回二进制数组的BASE64编码结果代码实例byte[]bs="泽元".getBytes();Stringbs_1=StringUtil.base64Encode(bs);bs_1为：5rO95YWDbase64Decode(Strings):byte[]将BASE64编码的字符串进行解码代码实例byte[]bs_1=StringUtil.base64Decode(bs);参数bs为：5rO95YWDbs_1为：[-26,-77,-67,-27,-123,-125]javaEncode(Stringtxt):String将字符串转换成可以在JAVA表达式中直接使用的字符串，处理一些转义字符代码实例Stringtxt="*?|/\t\"32";Stringtxt_1=StringUtil.javaEncode(txt);txt实际为：*?|/"32PS：tex中的"\t"表示空格txt_1为：*?|/\t\"32javaDecode(Stringtxt):String将StringUtil.javaEncode()处理过的字符还原代码实例Stringtxt="*?|/\t\"32";Stringtxt_1=StringUtil.javaEncode(txt);Stringtxt_2=StringUtil.javaDecode(txt_1);txt_2为：*?|/\t\"32splitEx(Stringstr,Stringspliter):String[]将一个字符串按照指定的分割字符串分割成数组。
stringutils的leftpad方法
stringutils的leftpad方法StringUtils 类是Apache Commons Lang 库中的一个类，提供了许多处理字符串的工具方法。
leftPad 方法是其中之一，用于在字符串的左侧填充指定的字符，使字符串达到指定的长度。
以下是关于StringUtils 类的leftPad 方法的详细介绍：StringUtils 类StringUtils 类是Apache Commons Lang 库中的一部分，用于提供对字符串进行操作的一系列工具方法。
这个类包含了许多实用的方法，涵盖了字符串的处理、比较、连接等多个方面。
leftPad 方法方法签名：public static String leftPad(String str,int size,char padChar)参数：•str：要填充的字符串。
•size：填充后字符串的总长度。
•padChar：用于填充的字符。
返回值：返回填充后的字符串。
leftPad 方法用于在字符串的左侧填充指定字符，使得字符串达到指定的长度。
如果原始字符串长度已经达到或超过了指定的长度，将不进行填充，直接返回原始字符串。
示例：import ng3.StringUtils;public class LeftPadExample {public static void main(String[]args){String originalString ="123";int targetLength =5;char paddingChar ='0';String paddedString =StringUtils.leftPad(originalString,targ etLength,paddingChar);System.out.println("Original String: "+originalString);System.out.println("Padded String: "+paddedString);}}Original String: 123Padded String: 00123上述示例中，原始字符串是"123"，目标长度是5，填充字符是'0'。
stringutils 去掉指定字符之间的字符串
stringutils 去掉指定字符之间的字符串如何使用StringUtils去除指定字符之间的字符串在日常的软件开发中，我们经常会遇到需要处理字符串的需求。
而Apache Commons Lang库中提供的StringUtils类是一个非常实用的工具类，其中的方法可以方便地处理字符串。
那么，如何使用StringUtils去除指定字符之间的字符串呢？接下来，我们将一步一步回答这个问题。
步骤一：导入依赖首先，在你的项目中引入Apache Commons Lang库的依赖。
你可以在pom.xml文件中添加如下代码：<dependency><groupId>org.apachemons</groupId><artifactId>commons-lang3</artifactId><version>3.12.0</version></dependency>然后，重新构建你的项目，确保依赖已经正确导入。
步骤二：编写代码在你的Java程序中，导入StringUtils类：javaimport ng3.StringUtils;接下来，我们来编写一个方法，实现去除指定字符之间的字符串功能：javapublic static String removeStringBetween(String original, char startChar, char endChar) {StringBuilder result = new StringBuilder(original);int startIndex = StringUtils.indexOf(original, startChar);int endIndex = StringUtils.indexOf(original, endChar, startIndex + 1);if (startIndex != -1 && endIndex != -1) {result.delete(startIndex, endIndex + 1);}return result.toString();这个方法接受三个参数：original是原始字符串，startChar是开始字符，endChar是结束字符。
十个最常用的StringUtils方法
1.取得字符串的缩写使用函数: StringUtils.abbreviate(testString,width)和StringUtils.abbreviate(testString,offset，width)函数介绍:在给定的width内取得testString的缩写,当testString的长度小于width则返回原字符串.例程:String test = "This is a test of the abbreviation.";String test2 = "Test";System.out.println( StringUtils.abbreviate( test, 15 ) );System.out.println( StringUtils.abbreviate( test, 5,15 ) );System.out.println( StringUtils.abbreviate( test2, 10 ) );输出如下: This is a te... ...is a test... Tes2.查找嵌套字符串使用函数:StringUtils.substringBetween(testString,header,tail)函数介绍：在testString中取得header和tail之间的字符串。
不存在则返回空例程：String htmlContent = "ABC1234ABC4567";System.out.println(StringUtils.substringBetween(htmlContent, "1234", "4567")); System.out.println(StringUtils.substringBetween(htmlContent, "12345", "4567"));输出如下：ABCnull3.重复字符串使用函数:StringUtils.repeat(repeatString,count)函数介绍:得到将repeatString重复count次后的字符串例程:System.out.println( StringUtils.repeat( "*", 10));System.out.println( StringUtils.repeat( "China ", 5));输出如下:**********China China China China China其他函数:StringUtils.center( testString, count,repeatString );函数介绍:把testString插入将repeatString重复多次后的字符串中间,得到字符串的总长为count例程:System.out.println( StringUtils.center( "China", 11,"*"));输出如下:***China***4.颠倒字符串使用函数:StringUtils.reverse(testString)函数介绍:得到testString中字符颠倒后的字符串例程:System.out.println( StringUtils.reverse("ABCDE"));输出如下:EDCBA5.空字符串检查使用函数: StringUtils.isBlank(testString)函数介绍: 当testString为空,长度为零或者仅由空白字符(whitespace)组成时,返回True;否则返回False例程:String test = "";String test2 = "\n\n\t";String test3 = null;String test4 = "Test";String test5 = " ";System.out.println( "test blank? " + StringUtils.isBlank( test ) );System.out.println( "test2 blank? " + StringUtils.isBlank( test2 ) );System.out.println( "test3 blank? " + StringUtils.isBlank( test3 ) );System.out.println( "test4 blank? " + StringUtils.isBlank( test4 ) );System.out.println( "test5 blank? " + StringUtils.isBlank( test5 ) );输出如下:test blank? truetest2 blank? truetest3 blank? truetest4 blank? Falsetest5 blank? true函数StringUtils.isNotBlank(testString)的功能与StringUtils.isBlank(testString)相反. 函数StringUtils.isEmpty(str). 判断某字符串是否为空，为空的标准是str == null 或str.length() == 0 (当str有空格时，结果为false)6.判断字符串内容的类型函数介绍:StringUtils.isNumeric( testString ) :如果testString全由数字组成返回True StringUtils.isAlpha( testString ) :如果testString全由字母组成返回True StringUtils.isAlphanumeric( testString ) :如果testString全由字母或数字组成返回TrueStringUtils.isAlphaSpace( testString ) :如果testString全由字母或空格组成返回True 例程:String state = "Virginia";System.out.println( "Is state number? " + StringUtils.isNumeric(state ) ); System.out.println( "Is state alpha? " + StringUtils.isAlpha( state ));System.out.println( "Is state alphanumeric? "+StringUtils.isAlphanumeric( state ) );System.out.println( "Is state alphaspace? " + StringUtils.isAlphaSpace( state ) ); 输出如下:Is state number? falseIs state alpha? trueIs state alphanumeric? trueIs state alphaspace? true7.取得某字符串在另一字符串中出现的次数使用函数:StringUtils.countMatches(testString,seqString)函数介绍:取得seqString在testString中出现的次数,未发现则返回零例程:System.out.println(StringUtils.countMatches( "Chinese People", "e"));输出:48.字符串两端不能以指定的字符串中的字符开始或结尾，StringUtils.strip(String str, String stripChars)函数介绍:去掉str两端的在stripChars中的字符。
stringutils 去掉指定字符之间的字符串 -回复
stringutils 去掉指定字符之间的字符串-回复如何使用StringUtils去掉指定字符之间的字符串`StringUtils`是一个Java库，它提供了一些方便的方法来处理字符串。
在本文中，我们将学习如何使用`StringUtils`的方法来去除指定字符之间的字符串。
让我们逐步进行以下操作。
步骤一：导入StringUtils库首先，我们需要确保我们已经将`StringUtils`库导入到我们的Java项目中。
可以通过`import`语句来实现。
javaimport ng3.StringUtils;步骤二：创建一个Java方法来去除指定字符之间的字符串接下来，我们将创建一个Java函数来去除指定字符之间的字符串。
该函数将接受三个参数：原始字符串、起始字符和结束字符。
它将返回一个新的字符串，其中删除了起始字符和结束字符之间的字符串。
javapublic static String removeBetween(String original, char startChar,char endChar) {StringBuilder result = new StringBuilder();boolean isBetweenChars = false;for (int i = 0; i < original.length(); i++) { char currentChar = original.charAt(i);if (currentChar == startChar) {isBetweenChars = true;continue;}if (currentChar == endChar) {isBetweenChars = false;continue;}if (!isBetweenChars) {result.append(currentChar);}}return result.toString();}步骤三：测试我们的方法现在，我们可以编写一个简单的测试代码来验证我们的方法是否按预期工作。
stringutils的用法
stringutils的用法1.简介`s tr in gu ti ls`是一个常用的字符串处理工具库，它提供了一系列方便的方法来处理和操作字符串。
无论是字符串的拼接、截取、替换还是格式化，`st ri ng ut il s`都可以派上用场。
本文将重点介绍`s tr in gu ti ls`的常见用法及示例。
2.字符串拼接`s tr in gu ti ls`提供了多个方法用于字符串拼接，其中最常用的是`c on ca t`方法。
该方法可以将多个字符串连接成一个字符串，并返回连接后的结果。
示例代码：S t ri ng st r1="He llo";S t ri ng st r2="Wo rld";S t ri ng re su lt=S tri n gU ti ls.c on ca t(s t r1,s tr2);3.字符串截取`s tr in gu ti ls`提供了一系列方法用于截取字符串的特定部分。
常用的截取方法包括`sub s tr in g`、`le ft`、`ri gh t`等。
这些方法可根据指定的起始位置和长度截取出子字符串。
示例代码：S t ri ng st r="H el loW o rl d";S t ri ng su b1=S tr ing U ti ls.s ub st ri ng(s tr,0,5);//输出"H el lo"S t ri ng su b2=S tr ing U ti ls.l ef t(st r,5);//输出"He ll o"S t ri ng su b3=S tr ing U ti ls.r ig ht(s tr,5);//输出"W or ld"4.字符串替换`s tr in gu ti ls`提供了多个方法用于字符串替换。
其中最常见的是`r ep la ce`方法，它可以将字符串中的某个字符或子字符串替换为指定的新字符串。
stringutils用法
stringutils用法StringUtils用法在Java开发中，字符串是我们经常需要处理的一种数据类型。
Java提供了许多处理字符串的方法，其中一个非常常用且功能强大的类就是StringUtils类。
StringUtils类是Apache Commons Lang库中的一员，它提供了各种字符串处理相关的工具方法，可以大大简化我们处理字符串的代码。
本文将详细介绍StringUtils类的使用方法，包括字符串操作、字符串比较、字符串修改等功能，并且将通过一些示例代码来说明每个方法的具体用法。
一、字符串操作1. isEmpty(String str)StringUtils的isEmpty方法用于判断给定的字符串是否为空或长度为0。
它的用法非常简单，只需传入一个字符串参数即可：javaStringUtils.isEmpty(str);如果传入的字符串为空或长度为0，则返回true；否则返回false。
举个例子：javaString str = "";boolean isEmpty = StringUtils.isEmpty(str); 返回trueString str2 = "Hello World";boolean isEmpty2 = StringUtils.isEmpty(str2); 返回false2. isNotEmpty(String str)与isEmpty方法相反，StringUtils的isNotEmpty方法用于判断给定的字符串是否不为空且长度大于0。
它的用法与isEmpty方法类似：javaStringUtils.isNotEmpty(str);如果传入的字符串不为空且长度大于0，则返回true；否则返回false。
举个例子：javaString str = "";boolean isNotEmpty = StringUtils.isNotEmpty(str); 返回falseString str2 = "Hello World";boolean isNotEmpty2 = StringUtils.isNotEmpty(str2); 返回true 3. isBlank(String str)StringUtils的isBlank方法用于判断给定的字符串是否为空、长度为0，或只包含空白字符。
stringutils.substring使用方法
stringutils.substring使用方法StringUtils.substring是Apache Commons Lang库中的一个方法，用于从字符串中提取子字符串。
它具有多种使用方式和参数设置，方便用于不同的场景。
该方法的常用用法有两种：1. public static String substring(String str, int start)这是最基本的使用方式，用于从指定位置开始截取字符串，并返回截取后的字符串。
其中，参数str是需要被截取的字符串，start是截取起始位置的索引值（从0开始计数）。
如果start超出了字符串的长度，则返回空字符串。
示例1：```javaString str = "Hello World";String result = StringUtils.substring(str, 6); //结果为"World"```示例2：```javaString str = "Hello World";String result = StringUtils.substring(str, 11); //结果为空字符串```2. public static String substring(String str, int start, int end)这是带有截取起始和结束位置的使用方式，用于从字符串中截取一部分，并返回截取后的字符串。
其中，参数str是需要被截取的字符串，start是截取起始位置的索引值（从0开始计数），end是截取结束位置的索引值（不包括该位置的字符）。
如果start或end超出了字符串的长度，则返回空字符串。
当start大于end时，会进行参数交换再进行截取。
示例1：```javaString str = "Hello World";String result = StringUtils.substring(str, 6, 11); //结果为"World"```示例2：```javaString str = "Hello World";String result = StringUtils.substring(str, 11, 6); //结果为"World"，即使start大于end，截取时会进行参数交换```示例3：```javaString str = "Hello World";为"Hello"```除了这两种基本用法，StringUtils.substring还提供了一系列的重载方法，以便于在不同情况下使用。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
SubstringBefore/SubstringAfter/SubstringBetween – 子串提取依赖其它字符串。
Remove/Delete – 删除部分字符串。
Replace/Overlay - Searches a String and replaces one String with another
Replace/Overlay – 替换字符串的部分字符。
Chomp/Chop - removes the last part of a String
IsEmpty/IsBlank – 检查字符串是否有内容。
Trim/Strip - removes leading and trailing whitespace
Trim/Strip – 删除字符串开始和结尾的空白符。
Equals - compares two strings null-safe
Abbreviate – 缩写字符串用省略符。
Difference - compares two Strings and reports on their differences
Difference – 比较两个字符串并且返回不同。
LevensteinDistance - the number of changes needed to change one String into another
trim - the characters <= 32 as in String.trim()去掉字符串两边字符<=32
Version:
$Id: StringUtils.java 492377 2007-01-04 01:20:30Z scolebourne $
UpperCase/LowerCase/SwapCase/Capitalize/Uncapitalize – 改变字符串的大小写。
CountMatches - counts the number of occurrences of one String in another
CountMatches – 计算一个字符或字符串在另外一个字符串出现的次数。
public class StringUtils
extends Object
Operations on String that are null safe. 字符串是null安全的，不会抛出NullPointerException，都做了相应的处理。
IsEmpty/IsBlank - checks if a String contains text
LevensteinDistance – 一个字符串改变为另一个字符串需要改变的数量。
The StringUtils class defines certain words related to String handling.
StringUtils类是对字符串的处理。
null – null 空
ContainsOnly/ContainsNone – 字符在字符串中出现一次或一次也没有出现。
Substring/Left/Right/Mid - null-safe substring extractions
Substring/Left/Right/Mid – null安全子串的提取。
DefaultString –null安全，null转换为字符串。
Reverse/ReverseDelimited - reverses a String
Reverse/ReverseDelimited – 反转字符串。
Abbreviate - abbreviates a string using ellipsis
IndexOfAny/LastIndexOfAny/Inde。
ContainsOnly/ContainsNone - does String contains only/none of these characters
Chomp/Chop – 删除字符串最后的字符。
LeftPad/RightPad/Center/Repeat - pads a String
LeftPad/RightPad/Center/Repeat – 补字符串。
UpperCase/LowerCase/SwapCase/Capitalize/Uncapitalize - changes the case of a String
empty - a zero-length string ("") 长度为0的字符串
space - the space character (' ', char 32) 间隔符
whitespace - the characters defined by Character.isWhitespace(char) 空格符
Equals – 比较两个字符串null安全。
IndexOf/LastIndexOf/Contains - null-safe index-of checks
IndexOf/LastIndexOf/Contains – null安全的索引检查。
IndexOfAny/LastIndexOfAny/IndexOfAnyBut/LastIndexOfAnyBut - index-of any of a set of Strings
IsAlpha/IsNumeric/IsWhitespace/IsAsciiPrintable - checks the characters in a String
IsAlpha/IsNumeric/IsWhitespace/IsAsciiPrintable – 判断字符是否在字符串中。
DefaultString - protects against a null input String
Split/Join - splits a String into an array of substrings and vice versa
Split/Join – 字符串拆分为子串的字符串数组，反之亦然。
Remove/Delete - removes part of a String