关于StringUtils的各种方法的功能、解析

<div class="iteye-blog-content-contain" style="font-size: 14px">

这些是个人，为了加强StringUtils方法的记忆，随便写写的，希望大家喜欢

public class StringUtilsTest extends TestCase {

// 将字符串转换成小写
@Test
public void test_lowerCase() {
// assertEquals("aaa", StringUtils.lowerCase("AAA"));
// assertEquals("", StringUtils.lowerCase("")); true
// assertEquals("aa", StringUtils.lowerCase("Aa")); true
// assertEquals("aa", StringUtils.lowerCase("aa")); true
// System.out.println(StringUtils.lowerCase(""));
assertEquals(null, StringUtils.lowerCase(null));
}

// 将字符串转换成大写
@Test
public void test_upperCase() {
// System.out.println(StringUtils.upperCase("aaa"));
assertEquals("AAA", StringUtils.upperCase("aaa"));
assertEquals(null, StringUtils.upperCase(null));
}

// 从第几个字符串开始省略
@Test
public void test_abbreviate() {
assertEquals("aa...", StringUtils.abbreviate("aaaa bbbb cccc", 5));
// maxWidth最小为4
// System.out.println(StringUtils.abbreviate("aabbccddeeffgg", 6));
assertEquals(null, StringUtils.abbreviate(null, 4));
}

// 对字符串lenth对半分middle是中间分隔符
@Test
public void test_abbreviateMiddle() {
// System.out.println(StringUtils.abbreviateMiddle("abcdefghijk", "-",
// 7));
assertEquals("ab-fg", StringUtils.abbreviateMiddle("abcdefg", "-", 5));
}

// 判断字符串是否为空或者是为null
@Test
public void test_isBlank() {
assertEquals(false, StringUtils.isBlank("aaa"));
assertEquals(true, StringUtils.isBlank(""));
// System.out.println(StringUtils.isBlank("aaa"));
}

// 判断字符串非空或者是非null
@Test
public void test_isNotBlank() {
assertEquals(false, StringUtils.isNotBlank(""));
assertEquals(true, StringUtils.isNotBlank("adsfa"));
}

// 首写字母大写
@Test
public void test_capitalize() {
assertEquals("Aaa", StringUtils.capitalize("aaa"));
assertEquals("", StringUtils.capitalize(""));
}

// 首写字母小写
@Test
public void test_uncapitalize() {
assertEquals("aAA", StringUtils.uncapitalize("AAA"));
}

// 以本在字符串在中间，两边用padStr来填充
@Test
public void test_center() {
// System.out.println(StringUtils.center("aaaaa", 10));
// System.out.println(StringUtils.center("aaa", 7, "--"));
// assertEquals("--aa--", StringUtils.center("aa", 6, "--"));
assertEquals(null, StringUtils.center(null, 6, "--"));
}

// 左侧填充
@Test
public void test_leftPad() {
assertEquals("--aa", StringUtils.leftPad("aa", 4, "-"));
}

// 右侧填充
@Test
public void test_rightPad() {
assertEquals("aa--", StringUtils.rightPad("aa", 4, "-"));
}

// 重复字符串
@Test
public void test_repeat() {
assertEquals("abcabc", StringUtils.repeat("abc", 2));
assertEquals("abcbcabc", StringUtils.repeat("abc", "bc", 2));
}

// 是否全部小写 不能为null
@Test
public void test_isAllLowerCase() {
assertEquals(true, StringUtils.isAllLowerCase("adfadfa"));
}

// 是否全部大写 不能为null
@Test
public void test_isAllUpperCase() {
assertEquals(true, StringUtils.isAllUpperCase("AFADF"));
// assertEquals(null, StringUtils.isAllUpperCase(null)); 不能为null
}

// 全部由字母组成
@Test
public void test_isAlpha() {
assertEquals(true, StringUtils.isAlpha("adsfad"));
}

// 全部由字母跟空格组成
@Test
public void test_isAlphaSpace() {
assertEquals(true, StringUtils.isAlphaSpace("afdsf   asfdad"));
// assertEquals(null, StringUtils.isAlphaSpace(null)); 不能为null
}

// 只由字母和数字组成
@Test
public void test_isAlphanumeric() {
assertEquals(true, StringUtils.isAlphanumeric("adfad12321"));
}

// 只由字母数字和空格组成
@Test
public void test_isAlphanumericSpace() {
assertEquals(true, StringUtils.isAlphanumericSpace("adsfa  1232 adsf "));
}

// 只由数字
@Test
public void test_isNumeric() {
assertEquals(true, StringUtils.isNumeric("12312"));
}

// 只由数字和空格
@Test
public void test_isNumericSpace() {
assertEquals(true, StringUtils.isNumericSpace("12312   "));
}

// 小写字符串在大写字符串中的匹配次数
@Test
public void test_countMatches() {
assertEquals(3, StringUtils.countMatches(
"asdfasdfasdfasfdqwefvdasvfqwefadsvqwef", "asdf"));
// System.out.println(StringUtils.countMatches("asdfasdfasdfasfdqwefvdasvfqwefadsvqwef",
// "asdf"));
}

// 字符串倒转
@Test
public void test_reverse() {
assertEquals("asdf", StringUtils.reverse("fdsa"));
assertEquals(null, StringUtils.reverse(null));
}

// 大小写转换，空格不动
@Test
public void test_swapCase() {
assertEquals("aB - cD", StringUtils.swapCase("Ab - Cd"));
}

// 去掉两端控制字符
@Test
public void test_trim() {
// System.out.println(StringUtils.trim("  aa bb cc   \t"));
assertEquals("", StringUtils.trim("        "));
assertEquals("aa bb cc", StringUtils.trim("   aa bb cc \t \b"));
assertEquals(null, StringUtils.trim(null));
}

// 去掉两端控制字符 跟 trim()方法是一个样的
@Test
public void test_trimToNull() {
// System.out.println(StringUtils.trim("  aa bb cc   \t"));
assertEquals(null, StringUtils.trimToNull("   "));
assertEquals("aa bb cc", StringUtils.trimToNull("   aa bb cc \t \b"));
assertEquals(null, StringUtils.trim(null));
}

// 去掉两端控制字符 跟 trim()方法是一个样的
@Test
public void test_trimToEmpty() {
// System.out.println(StringUtils.trim("  aa bb cc   \t"));
assertEquals("", StringUtils.trimToEmpty("  "));
assertEquals("aa bb cc", StringUtils.trimToEmpty("   aa bb cc \t \b"));
assertEquals(null, StringUtils.trim(null));
assertEquals("", StringUtils.trim(""));
}

// 去掉字符串两端的空白符
@Test
public void test_strip() {
assertEquals("aa bb cc", StringUtils.strip("  aa bb cc    \t    "));
}

@Test
public void test_stripToNull() {
assertEquals("aa bb cc",
StringUtils.stripToNull("  aa bb cc    \t    "));
assertEquals(null, StringUtils.stripToNull(""));
assertEquals(null, StringUtils.stripToNull(null));
}

@Test
public void test_stripToEmpty() {
assertEquals("aa bb cc", StringUtils.stripToEmpty("   aa bb cc "));
assertEquals("", StringUtils.stripToEmpty(null));
assertEquals("", StringUtils.stripToEmpty(""));
}

// 删除从结尾开始的小字符串
@Test
public void test_stripEnd() {
assertEquals("as", StringUtils.stripEnd("asdfghjkl", "dfghjkl"));
}

// 删除冲开头开始的小字符串
@Test
public void test_stripStart() {
assertEquals("kl", StringUtils.stripStart("asdfghjkl", "asdfghj"));
assertEquals("", StringUtils.stripStart("", ""));
assertEquals(null, StringUtils.stripStart(null, null));
}

//去掉每个元素开始和结尾的空格
@Test
public void test_stripAll() {
String[] temp1 = {"ads  ", " dsaf"};
String[] temp2 = {"ads", "dsaf"};
assertEquals("[ads, dsaf]", java.util.Arrays.toString(StringUtils.stripAll(temp1)));
System.out.println(java.util.Arrays.toString(StringUtils.stripAll(temp1)));
}

// 无论大小写，对面是否相等
@Test
public void test_equalsIgnoreCase() {
assertEquals(true, StringUtils.equalsIgnoreCase("aA", "aa"));
}

// 验证字符出现的第一个位置
@Test
public void test_indexOf() {
assertEquals(1, StringUtils.indexOf("assddss", "s"));
assertEquals(-1, StringUtils.indexOf("assddss", "2"));
assertEquals(-1, StringUtils.indexOf(null, "2"));
assertEquals(-1, StringUtils.indexOf("", "2"));
assertEquals(5, StringUtils.indexOf("assddss", "s", 4));
}

@Test
public void test_ordinalIndexOf() {
assertEquals(14, StringUtils.ordinalIndexOf("aabbccddeeffggaa", "a", 3));
}

@Test
public void test_contains() {
assertEquals(true, StringUtils.contains("aabbccddeeffgg", "bb"));
assertEquals(false, StringUtils.contains(null, ""));
assertEquals(true, StringUtils.contains("", ""));
assertEquals(false, StringUtils.contains("", null));
assertEquals(false, StringUtils.contains(null, null));
}

@Test
public void test_containsIgnoreCase() {
assertEquals(true, StringUtils.containsIgnoreCase("ASDFghjKL", "FGHJ"));
}

// 小字符串在大字符串中的第一个出现的位置
@Test
public void test_indexOfAny() {
assertEquals(2, StringUtils.indexOfAny("asdfghjkl", "dfg"));
}

// 小字符串不在大字符串中出现的第一个位置
@Test
public void test_indexOfAnyBut() {
assertEquals(0, StringUtils.indexOfAnyBut("asdfghjkl", "dfg"));
}

// 大字符串是否仅仅只包含小字符串中的内容
@Test
public void test_containsOnly() {
assertEquals(true, StringUtils.containsOnly("adsfasdfas", "asdf"));
}

// 大字符串中不包含小字符串的内容
@Test
public void test_containsNone() {
assertEquals(false, StringUtils.containsNone("as", "adsf"));
}

// 小字符串在大字符串中最后一次出现的位置
@Test
public void test_lastIndexOf() {
assertEquals(8, StringUtils.lastIndexOf("aabbccedaa", "aa"));
}

// 从规定的下标数开始截取字符串
@Test
public void test_substring() {
assertEquals("sdf", StringUtils.substring("asdfgh", 1, 4));
}

// 在大字符串中存在于小字符串过后的内容
@Test
public void test_substringAfter() {
assertEquals("hjkl", StringUtils.substringAfter("asdfghjkl", "sdfg"));
}

// 在大字符串中存在于小字符串之前的内容
@Test
public void test_substringBefore() {
assertEquals("a", StringUtils.substringBefore("asdfghjkl", "sdfg"));
}

// 在大字符串中存在于两个小字符转中的内容
@Test
public void test_substringBetween() {
assertEquals("sd", StringUtils.substringBetween("asdfgh", "a", "f"));
}

// 在最后一个tag字符串的后面的内容
@Test
public void test_substringAfterLast() {
assertEquals("bb", StringUtils.substringAfterLast("tagabctagbb", "tag"));
}

// 在最后一个tag字符串前面的内容
@Test
public void test_substringBeforeLast() {
assertEquals("tagaatagbb",
StringUtils.substringBeforeLast("tagaatagbbtagcc", "tag"));
}

// 输出多个字符串中间的内容
@Test
public void test_substringsBetween() {
System.out.println(StringUtils.substringsBetween("[a],[b],[c]", "[",
"]"));
}

// 在左边的第几个字符的内容
@Test
public void test_left() {
assertEquals("as", StringUtils.left("asdfg", 2));
assertEquals(null, StringUtils.left(null, 2));
}

// 对字符串右边第几个字符串的内容
@Test
public void test_right() {
assertEquals("fg", StringUtils.right("asdfg", 2));
}

// 省略字符串中的空格,然后用数组的形式输出
@Test
public void test_split() {
assertEquals("[aa, bb, cc]",
java.util.Arrays.toString(StringUtils.split("aa bb cc   ")));
}

// 将字符串中不用一类型的，所有字符分割开来
@Test
public void test_splitByCharacterType() {
assertEquals("[number, 5]", java.util.Arrays.toString(StringUtils
.splitByCharacterType("number5")));
}

// 规定分隔符
@Test
public void test_splitByWholeSeparator() {
assertEquals("[aa, bb, cc]", java.util.Arrays.toString(StringUtils
.splitByWholeSeparator("aa bb cc", " ")));
}

@Test
public void test_splitPreserveAllTokens() {
assertEquals("[, aa, bb, , ccdd]",
java.util.Arrays.toString(StringUtils
.splitPreserveAllTokens(" aa bb  ccdd")));
}

// 把字符数的内容变成字符串
@Test
public void test_join() {
assertEquals("abc", StringUtils.join(new String[] { "a", "b", "c" }));
}

// 删除字符串黄总所有的空白字符
@Test
public void test_deleteWhitespace() {
assertEquals("abc", StringUtils.deleteWhitespace("a\n   \fb   \rc"));
}

// 删除指定的字符
@Test
public void test_remove() {
assertEquals("abde", StringUtils.remove("abcde", "c"));
}

// 只能删除最后的一节字符串
@Test
public void test_removeEnd() {
assertEquals("abc", StringUtils.removeEnd("abcde", "de"));
assertEquals("abcde", StringUtils.removeEnd("abcde", "c"));
}

// 无论大小写删除最后一段字符
@Test
public void test_removeEndIgnoreCase() {
assertEquals("aBc", StringUtils.removeEndIgnoreCase("aBcDe", "de"));
}

@Test
public void test_removeStart() {
assertEquals("de", StringUtils.removeStart("abcde", "abc"));
}

@Test
public void test_removeStartIgnoreCase() {
assertEquals("CdE", StringUtils.removeStartIgnoreCase("AbCdE", "Ab"));
}

// 替换字符串中的指定字符
@Test
public void test_replace() {
assertEquals("adsfg", StringUtils.replace("asdfg", "sd", "ds"));
}

// 指定单个字符替换
@Test
public void test_replaceChars() {
assertEquals("bbcde", StringUtils.replaceChars("abcde", 'a', 'b'));
}

// 通过数组来一组替换
@Test
public void test_replaceEach() {
assertEquals("wcze", StringUtils.replaceEach("abcde", new String[] {
"ab", "d" }, new String[] { "w", "z" }));
}

// 只替换第一个找到的元素
@Test
public void test_replaceOnce() {
assertEquals("zbcad", StringUtils.replaceOnce("abcad", "a", "z"));
}

// 规定长度的替换规定的元素
@Test
public void test_overlay() {
assertEquals("attdd", StringUtils.overlay("aabbccdd", "tt", 1, 6));
}

// 删除最后一个以 \n \r \t 结尾的字符
@Test
public void test_chomp(){
System.out.println(StringUtils.chomp("\nASDF \n\r\n\r\n asdf\n"));
}

}

</div>