StringUtils工具类常用方法
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)：字符串右边的多少个字符。
java中stringutil.obj2str用法_概述说明
java中stringutil.obj2str用法概述说明1. 引言1.1 概述本篇长文旨在介绍Java中的字符串工具类StringUtil中的obj2str方法的使用方法和功能。
字符串在开发过程中起到了至关重要的作用，而StringUtil类提供了丰富的方法来处理和转换字符串。
其中，obj2str方法是将对象转换为字符串的重要方法之一。
1.2 文章结构本文按照以下结构进行介绍和说明：引言：对文章进行概述，简要介绍文章内容和目的。
字符串工具类(StringUtil)简介：对StringUtil类进行简单介绍，包括其功能概述、使用方法和返回结果说明。
对象转字符串(obj2str)方法介绍：详细阐述obj2str方法的概述、参数说明和使用示例。
注意事项和常见问题解答：解答一些常见问题，例如转换失败如何处理、如何处理特殊字符以及是否支持自定义转换规则等。
结论与总结：总结全文内容和要点，并提出进一步研究的方向或建议。
1.3 目的本文旨在帮助读者理解并正确使用StringUtil类中的obj2str方法。
通过本文，读者将能够掌握该方法的核心功能、使用方式以及注意事项。
同时，读者还可以了解一些常见问题，并学会如何解决这些问题。
最后，通过总结和提供进一步研究的方向或建议，本文将为读者提供一个全面的指引，使其能够更好地应用和拓展这一方法。
2. 字符串工具类(StringUtil)简介：2.1 功能概述:字符串工具类(StringUtil)是Java语言中常用的一个工具类，提供了一系列对字符串进行操作的方法。
它封装了常见的字符串处理功能，包括字符串的截取、替换、连接、格式化等操作。
StringUtil类的目标是简化开发人员对字符串的处理，提高代码的可读性和复用性。
2.2 使用方法:使用StringUtil类中的方法非常简单。
首先需要导入StringUtil类所在的包，在需要使用的地方创建一个StringUtil对象或直接调用静态方法即可。
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.substring使用方法
stringutils.substring使用方法（最新版5篇）目录（篇1）1.StringUtils.substring() 方法介绍2.StringUtils.substring() 方法参数3.StringUtils.substring() 方法示例4.StringUtils.substring() 方法优点与不足正文（篇1）【1.StringUtils.substring() 方法介绍】StringUtils.substring() 是 Java 中一个常用的字符串处理方法，它属于 Apache Commons Lang 库中的 StringUtils 工具类。
该方法的作用是提取字符串中的一个子字符串，并返回一个新的 String 对象。
这对于在字符串操作中需要截取部分字符串的情况非常有用。
【2.StringUtils.substring() 方法参数】StringUtils.substring() 方法接收两个参数，分别是：1.开始索引（int start）：表示从哪个字符开始提取子字符串，索引从 0 开始。
如果开始索引小于 0 或大于字符串长度，将抛出IllegalArgumentException 异常。
2.结束索引（int end）：表示从哪个字符结束提取子字符串，索引从0 开始。
如果结束索引小于开始索引或大于字符串长度，将抛出IllegalArgumentException 异常。
【3.StringUtils.substring() 方法示例】以下是 StringUtils.substring() 方法的示例：```javaimport ng3.StringUtils;public class SubstringExample {public static void main(String[] args) {String str = "Hello, World!";String subStr1 = StringUtils.substring(str, 0, 5); // 结果为 "Hello"String subStr2 = StringUtils.substring(str, 6, 11); // 结果为 "World"System.out.println(subStr1);System.out.println(subStr2);}}```【4.StringUtils.substring() 方法优点与不足】优点：1.StringUtils.substring() 方法简洁易用，方便开发者进行字符串操作。
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常用方法StringUtils是Java中常用的字符串操作工具类，提供了许多方便的方法来操作字符串。
以下是几个常用的方法：1. isEmpty(CharSequence cs): 判断传入的CharSequence是否为空或长度为0。
2. isNotEmpty(CharSequence cs): 判断传入的CharSequence是否不为空且长度大于0。
3. trim(String str): 返回去除首尾空格的字符串。
4. equals(CharSequence cs1, CharSequence cs2): 比较两个CharSequence是否相等，忽略大小写。
5. equalsIgnoreCase(CharSequence cs1, CharSequence cs2): 比较两个CharSequence是否相等，不忽略大小写。
6. substring(String str, int start, int end): 返回从指定位置开始到指定位置结束的子字符串。
7. join(Object[] array, String separator): 使用指定的分隔符连接数组中的元素。
8. replace(String text, String searchString, String replacement): 替换字符串中的指定文本为新的文本。
9. split(String str, String separator): 使用指定的分隔符将字符串拆分成数组。
除了以上几个方法，StringUtils还提供了很多其他的字符串操作方法，如截取、填充、反转、大小写转换等等。
在实际开发中，经常会用到StringUtils来简化字符串的操作，提高开发效率。
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左右补齐⽅法，具体使⽤⽅法跟上⾯类似。
十个最常用的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.matches用法
stringutils.matches用法全文共四篇示例，供读者参考第一篇示例：StringUtils是Apache提供的一个操作字符串的工具类，其中有一个方法叫做matches，用来检查字符串是否符合某个正则表达式的规则。
本文将详细介绍StringUtils.matches方法的用法，并举例说明如何在实际项目中应用这一功能。
一、StringUtils.matches方法的基本用法StringUtils.matches方法的签名如下：```public static boolean matches(String str, String regex)```这个方法接收两个参数，第一个参数是待检查的字符串，第二个参数是正则表达式。
方法会根据正则表达式对字符串进行匹配，如果字符串符合正则表达式的规则，则返回true，否则返回false。
StringUtils.matches方法还支持忽略大小写进行匹配，只需在正则表达式中使用"(?i)"开启忽略大小写模式。
下面是一个例子，展示了如何忽略大小写地验证一个字符串是否为"hello"：```String str = "Hello";boolean result = StringUtils.matches(str, "(?i)hello");System.out.println(result); //输出true```三、实际项目中的应用场景StringUtils.matches方法在实际项目中有着广泛的应用场景，比如表单验证、数据过滤等。
下面我们以一个简单的注册表单验证为例，演示如何使用StringUtils.matches方法来验证用户输入的信息是否合法。
总结本文介绍了StringUtils.matches方法的基本用法和高级用法，并给出了在实际项目中的应用示例。
StringUtils.matches方法是一个十分实用的工具，能够帮助我们简洁地实现字符串的正则匹配功能，提高开发效率。
stringutils的比较方法
stringutils的比较方法在Java编程语言中，StringUtils类是一个常用的工具类，其中包含了许多用于字符串操作的方法。
其中之一就是比较字符串的方法。
StringUtils类中的比较方法有多种，让我们来逐一了解它们。
1. equals:StringUtils.equals(String str1, String str2)方法用于比较两个字符串是否相等。
它会判断两个字符串的内容是否相同，区分大小写。
示例代码如下：```String str1 = "Hello";String str2 = "hello";boolean isEqual = StringUtils.equals(str1, str2);System.out.println("str1和str2是否相等: " + isEqual);```2. equalsIgnoreCase:StringUtils.equalsIgnoreCase(String str1, String str2)方法用于比较两个字符串是否相等，忽略大小写。
示例代码如下：```String str1 = "Hello";String str2 = "hello";boolean isEqual = StringUtils.equalsIgnoreCase(str1, str2);System.out.println("str1和str2是否相等（忽略大小写）: " + isEqual);```3. compare:pare(String str1, String str2)方法用于比较两个字符串的大小。
返回一个整数值，用于表示比较的结果，如果str1小于str2，则返回负数；如果str1等于str2，则返回0；如果str1大于str2，则返回正数。
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方法全集ng.StringUtils中方法的操作对象是ng.String类型的对象，是JDK提供的String类型操作方法的补充，并且是null安全的(即如果输入参数String为null则不会抛出NullPointerException，而是做了相应处理，例如，如果输入为null 则返回也是null等，具体可以查看源代码)。
除了构造器，StringUtils中一共有130多个方法，并且都是static 的，所以我们可以这样调用StringUtils.xxx()。
下面分别对一些常用方法做简要介绍：1. public static boolean isEmpty(String str)判断某字符串是否为空，为空的标准是str == null 或 str.length() == 0下面是示例：StringUtils.isEmpty(null) = trueStringUtils.isEmpty('') = trueStringUtils.isEmpty(' ') = falseStringUtils.isEmpty(' ') = falseStringUtils.isEmpty('bob') = falseStringUtils.isEmpty(' bob ') = false2. public static boolean isNotEmpty(String str)判断某字符串是否非空，等于!isEmpty(String str)下面是示例：StringUtils.isNotEmpty(null) = falseStringUtils.isNotEmpty('') = falseStringUtils.isNotEmpty(' ') = trueStringUtils.isNotEmpty(' ') = trueStringUtils.isNotEmpty('bob')= trueStringUtils.isNotEmpty(' bob ') = true3. public static boolean isBlank(String str)判断某字符串是否为空或长度为0或由空白符(whitespace)构成下面是示例：StringUtils.isBlank(null) = trueStringUtils.isBlank('') = trueStringUtils.isBlank(' ') = trueStringUtils.isBlank(' ') = trueStringUtils.isBlank('\t \n \f \r') = trueStringUtils.isBlank('\b') = falseStringUtils.isBlank('bob') = falseStringUtils.isBlank(' bob ') = false4. public static boolean isNotBlank(String str)判断某字符串是否不为空且长度不为0且不由空白符(whitespace)构成，等于!isBlank(String str)下面是示例：StringUtils.isNotBlank(null) = falseStringUtils.isNotBlank('') = falseStringUtils.isNotBlank(' ') = falseStringUtils.isNotBlank(' ') = falseStringUtils.isNotBlank('\t \n \f \r') = falseStringUtils.isNotBlank('\b') = trueStringUtils.isNotBlank('bob') = trueStringUtils.isNotBlank(' bob ') = true5. public static String trim(String str)去掉字符串两端的控制符(control characters, char <= 32)如果输入为null则返回null下面是示例：StringUtils.trim(null) = nullStringUtils.trim('') = ''StringUtils.trim(' ') = ''StringUtils.trim(' \b \t \n \f \r ') = ''StringUtils.trim(' \n\tss \b') = 'ss'StringUtils.trim(' d d dd ') = 'd d dd'StringUtils.trim('dd ') = 'dd'StringUtils.trim(' dd ') = 'dd'6.public static String trimToNull(String str)去掉字符串两端的控制符(control characters, char <= 32) 如果变为null或''，则返回null下面是示例：StringUtils.trimToNull(null) = nullStringUtils.trimToNull('') = nullStringUtils.trimToNull(' ') = nullStringUtils.trimToNull(' \b \t \n \f \r ') = null StringUtils.trimToNull(' \n\tss \b') = 'ss' StringUtils.trimToNull(' d d dd ') = 'd d dd' StringUtils.trimToNull('dd ') = 'dd'StringUtils.trimToNull(' dd ') = 'dd'7.public static String trimToEmpty(String str)去掉字符串两端的控制符(control characters, char <= 32) 如果变为null或''，则返回''下面是示例：StringUtils.trimToEmpty(null) = ''StringUtils.trimToEmpty('') = ''StringUtils.trimToEmpty(' ') = ''StringUtils.trimToEmpty(' \b \t \n \f \r ') = '' StringUtils.trimToEmpty(' \n\tss \b') = 'ss' StringUtils.trimToEmpty(' d d dd ') = 'd d dd' StringUtils.trimToEmpty('dd ') = 'dd'StringUtils.trimToEmpty(' dd ') = 'dd'8.public static String strip(String str)去掉字符串两端的空白符(whitespace)，如果输入为null则返回null下面是示例(注意和trim()的区别)：StringUtils.strip(null) = nullStringUtils.strip('') = ''StringUtils.strip(' ') = ''StringUtils.strip(' \b \t \n \f \r ') = '\b' StringUtils.strip(' \n\tss \b') = 'ss \b' StringUtils.strip(' d d dd ') = 'd d dd' StringUtils.strip('dd ') = 'dd'StringUtils.strip(' dd ') = 'dd'9.public static String stripToNull(String str)去掉字符串两端的空白符(whitespace)，如果变为null或''，则返回null下面是示例(注意和trimToNull()的区别)：StringUtils.stripT oNull(null) = null StringUtils.stripT oNull('') = null StringUtils.stripT oNull(' ') = null StringUtils.stripT oNull(' \b \t \n \f \r ') = '\b' StringUtils.stripT oNull(' \n\tss \b') = 'ss \b' StringUtils.stripT oNull(' d d dd ') = 'd d dd' StringUtils.stripT oNull('dd ') = 'dd' StringUtils.stripT oNull(' dd ') = 'dd'10.public static String stripToEmpty(String str) 去掉字符串两端的空白符(whitespace)，如果变为null或''，则返回''下面是示例(注意和trimToEmpty()的区别)：StringUtils.stripT oNull(null) = ''StringUtils.stripT oNull('') = ''StringUtils.stripT oNull(' ') = ''StringUtils.stripT oNull(' \b \t \n \f \r ') = '\b'StringUtils.stripT oNull(' \n\tss \b') = 'ss \b'StringUtils.stripT oNull(' d d dd ') = 'd d dd'StringUtils.stripT oNull('dd ') = 'dd'StringUtils.stripT oNull(' dd ') = 'dd'11.public static String strip(String str, String stripChars)去掉str两端的在stripChars中的字符。
十个最常用的StringUtils方法
十个最常用的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(htmlConten t, "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用法在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还提供了一系列的重载方法，以便于在不同情况下使用。
SpringUtils工具类常用方法实例
SpringUtils⼯具类常⽤⽅法实例Spring提供的⼯具类，主要⽤于框架内部使⽤，这个类提供了⼀些简单的⽅法，并且提供了易于使⽤的⽅法在分割字符串，如CSV字符串，以及集合和数组。
StringUtils提供常⽤的⽅法如下：判断对象对象是否为null或者空字符串public static boolean isEmpty(@Nullable Object str) {return (str == null || "".equals(str));}判断给的序列是否为空或者length为0public static boolean hasLength(@Nullable CharSequence str) {return (str != null && str.length() > 0);}public static boolean hasLength(@Nullable String str) {return (str != null && !str.isEmpty());}判断字符串是否以某个字符串开头public static boolean startsWithIgnoreCase(@Nullable String str, @Nullable String prefix) {return (str != null && prefix != null && str.length() >= prefix.length() &&str.regionMatches(true, 0, prefix, 0, prefix.length()));}判断字符串是否以某个字符串结尾public static boolean endsWithIgnoreCase(@Nullable String str, @Nullable String suffix) {return (str != null && suffix != null && str.length() >= suffix.length() &&str.regionMatches(true, str.length() - suffix.length(), suffix, 0, suffix.length()));}⽤另⼀个字符串替换字符串中出现的所有⼦字符串public static String replace(String inString, String oldPattern, @Nullable String newPattern) {if (!hasLength(inString) || !hasLength(oldPattern) || newPattern == null) {return inString;}//oldPattern字符串第⼀次出现的位置int index = inString.indexOf(oldPattern);if (index == -1) {// no occurrence -> can return input as-isreturn inString;}//字符串长度int capacity = inString.length();if (newPattern.length() > oldPattern.length()) {capacity += 16;}StringBuilder sb = new StringBuilder(capacity);int pos = 0; // our position in the old stringint patLen = oldPattern.length();while (index >= 0) {sb.append(inString, pos, index);sb.append(newPattern);pos = index + patLen;index = inString.indexOf(oldPattern, pos);}// append any characters to the right of a matchsb.append(inString, pos, inString.length());return sb.toString();}根据给定的路径规范化路径public static String cleanPath(String path) {if (!hasLength(path)) {return path;}//⽤新字符串替换旧字符串String pathToUse = replace(path, WINDOWS_FOLDER_SEPARATOR, FOLDER_SEPARATOR);// Shortcut if there is no work to doif (pathToUse.indexOf('.') == -1) {return pathToUse;}// Strip prefix from path to analyze, to not treat it as part of the// first path element. This is necessary to correctly parse paths like// "file:core/../core/io/Resource.class", where the ".." should just// strip the first "core" directory while keeping the "file:" prefix.int prefixIndex = pathToUse.indexOf(':');String prefix = "";if (prefixIndex != -1) {prefix = pathToUse.substring(0, prefixIndex + 1);if (prefix.contains(FOLDER_SEPARATOR)) {prefix = "";}else {pathToUse = pathToUse.substring(prefixIndex + 1);}}if (pathToUse.startsWith(FOLDER_SEPARATOR)) {prefix = prefix + FOLDER_SEPARATOR;pathToUse = pathToUse.substring(1);}String[] pathArray = delimitedListToStringArray(pathToUse, FOLDER_SEPARATOR);LinkedList<String> pathElements = new LinkedList<>();int tops = 0;for (int i = pathArray.length - 1; i >= 0; i--) {String element = pathArray[i];if (CURRENT_PATH.equals(element)) {// Points to current directory - drop it.}else if (TOP_PATH.equals(element)) {// Registering top path found.tops++;}else {if (tops > 0) {// Merging path element with element corresponding to top path.tops--;}else {// Normal path element found.pathElements.add(0, element);}}}// Remaining top paths need to be retained.for (int i = 0; i < tops; i++) {pathElements.add(0, TOP_PATH);}// If nothing else left, at least explicitly point to current path.if (pathElements.size() == 1 && "".equals(pathElements.getLast()) && !prefix.endsWith(FOLDER_SEPARATOR)) { pathElements.add(0, CURRENT_PATH);}return prefix + collectionToDelimitedString(pathElements, FOLDER_SEPARATOR);}以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
System.out.println( "test1 trimToNull: " + StringUtils.trimToNull( test1 ) );
System.out.println( "test2 trimToNull: " + StringUtils.trimToNull( test2 ) );
); System.out.println( "Is state alphanumeric? "
+StringUtils.isAlphanumeric( state ) ); System.out.println( "Is state alphaspace? " +
StringUtils.isAlphaSpace( state ) ); 输出如下:
4.劈分字符串 使用函数: StringUtils.split(testString,splitChars,arrayLength) 函数介绍:splitChars 中可以包含一系列的字符串来劈分 testString,并可 以设定得 到数组的长度.注意设定长度 arrayLength 和劈分字符串间有抵触关系, 建议一般情况下 不要设定长度. 例程:
System.out.println(StringUtils.countMatches( "Chinese People", "e" StringUtils.substringBetween(testString,fromString,toString ):取得两
其他函数:StringUtils.center( testString, count,repeatString ); 函数介绍:把 testString 插入将 repeatString 重复多次后的字符串中间, 得到字符串 的总长为 count 例程:
System.out.println( StringUtils.center( "China", 11,"*")); 输出如下:
函数介绍：上面应该都讲明白了吧。 例程：
String formatted = " 25 * (30,40) [50,60] | 30"; System.out.print("N0: " + StringUtils.substringBeforeLast( formatted, "*" ) ); System.out.print(", N1: " + StringUtils.substringBetween( formatted, "(", "," ) ); System.out.print(", N2: " + StringUtils.substringBetween( formatted, ",", ")" ) ); System.out.print(", N3: " + StringUtils.substringBetween( formatted, "[", "," ) ); System.out.print(", N4: " + StringUtils.substringBetween( formatted, ",", "]" ) ); System.out.print(", N5: " +
字符 之间的字符串 StringUtils.substringAfter( ):取得指定字符串后的字符串 StringUtils.substringBefore( )：取得指定字符串之前的字符串 StringUtils.substringBeforeLast( )：取得最后一个指定字符串之前的字 符串 StringUtils.substringAfterLast( )：取得最后一个指定字符串之后的字符 串
9.判断字符串内容的类型 函数介绍: StringUtils.isNumeric( testString ) :如果 testString 全由数字组成返回 True StringUtils.isAlpha( testString ) :如果 testString 全由字母组成返回 True StringUtils.isAlphanumeric( testString ) :如果 testString 全由数字或数 字组 成返回 True StringUtils.isAlphaspace( testString ) :如果 testString 全由字母或空格 组 成返回 True
5.查找嵌套字符串 使用函数: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")); 输出如下： ABC null
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... Test
注意：函数 StringUtils.trim(testString)与 StringUtils.trimToNull(testString)功能类似，但 testString 由空白字符 (whitespace)组成时返回零长度字符串。
3.取得字符串的缩写 使用函数: StringUtils.abbreviate(testString,width)和 StringUtils.abbreviate(testString,offset，width) 函数介绍:在给定的 width 内取得 testString 的缩写,当 testString 的长度 小于 width 则返回原字符串. 例程:
String test = ""; String test2 = "\n\n\t"; String test3 = null; String test4 = "Test";
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 ) ); 输出如下: test blank? true test2 blank? true test3 blank? true test4 blank? False
System.out.println( ArrayUtils.toString( array1 ) ); System.out.println( ArrayUtils.toString( array2 ) ); 输出如下: {A,b,c,d,e} {Pharmacy,basketball funky}
7.重复字符串 使用函数:StringUtils.repeat(repeatString,count) 函数介绍:得到将 repeatString 重复 count 次后的字符串 例程:
System.out.println( StringUtils.repeat( "*", 10)); System.out.println( StringUtils.repeat( "China ", 5)); 输出如下: ********** China China China China China
Is state number? false Is state alpha? true Is state alphanumeric? true Is state alphaspace? true
10.取得某字符串在另一字符串中出现的次数 使用函数:StringUtils.countMatches(testString,seqString) 函数介绍:取得 seqString 在 testString 中出现的次数,未发现则返回零 例程: