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

这些是个人，为了加强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"));
    }
}