Guava字符串处理工具

作为开发中最常用的数据结构之一String，Apache、Sun等都有提供StringUtils各种工具包。JDK也自带一组String操作方法，极大方便了开发工作，但是诸如join、split使用起来确实不是很方便。基于此Guava提供了四种字符串处理工具连接器(Joiner)、拆分器(Splitter)、匹配器(CharMatcher)、格式器( CaseFormat)，本文会分四个章节讲述这四种工具的简单使用。

• Joiner

示例代码：

public class JoinerTest {
    @Test
    public void joinTest(){
        List<String> list = Lists.newArrayList("aaa", "bbb", null, "ccc");
        String joinStr = Joiner.on("-").skipNulls().join(list);
        assertEquals("aaa-bbb-ccc", joinStr);
    }

    @Test
    public void useForNullTest(){
        List<String> list = Lists.newArrayList("aaa", "bbb", null, "ccc");
        String joinStr = Joiner.on("-").useForNull("null").join(list);
        assertEquals("aaa-bbb-null-ccc", joinStr);
    }

    @Test
    public void appendToTest(){
        List<String> list = Lists.newArrayList("aaa", "bbb", null, "ccc");
        StringBuilder sb = new StringBuilder("this is: ");
        StringBuilder result = Joiner.on("-").skipNulls().appendTo(sb, list);
        assertEquals("this is: aaa-bbb-ccc", result.toString());
    }

    @Test
    public void withKeyValueSeparatorTest(){
        Map<Integer, String> idNameMap = Maps.newHashMap();
        idNameMap.put(1, "Michael");
        idNameMap.put(2, "Mary");
        idNameMap.put(3, "Jane");

        String result = Joiner.on("\n").withKeyValueSeparator(":").join(idNameMap);
        System.out.println(result);
    }
}

• Splitter

示例代码：

public class SplitterTest {
    @Test
    public void splitStringToIterableWithDelimiter() {
        /*通过Char初始化拆分器，将String分隔为Iterable*/
        String str = "this, is  , , random , text,";
        List<String> result = Lists.newArrayList(Splitter.on(',').omitEmptyStrings().trimResults().split(str));
        assertThat(result, contains("this", "is", "random", "text"));

        String str1 = "~?~this, is~~ , , random , text,";
        result = Splitter.on(',').omitEmptyStrings().trimResults(CharMatcher.anyOf("~? ")).splitToList(str1);
        System.out.println(result);
        assertThat(result, contains("this", "is", "random", "text"));
    }

    @Test
    public void splitStringToListWithDelimiter() {
        /*通过Char初始化拆分器，将String直接分隔为List*/
        String str = "this, is  , , random , text,";
        List<String> result = Splitter.on(',').omitEmptyStrings().trimResults().splitToList(str);
        assertThat(result, contains("this", "is", "random", "text"));

        /*生成的list不支持add、remove操作*/
        assertThatThrownBy(() -> result.add("haha"))
                .isInstanceOf(UnsupportedOperationException.class)
                .hasNoCause();
    }

    @Test
    public void splitStringToListWithCharMatcher() {
        /*通过CharMatcher初始化拆分器*/
        String str = "a,b;c.d,e.f),g,h.i;j.1,2.3;";

        List<String> result = Splitter.on(CharMatcher.anyOf(";,.)")).omitEmptyStrings().trimResults().splitToList(str);
        assertEquals(13, result.size());
    }

    @Test
    public void splitStringToListWithRegularExpression() {
        /*通过正则表达式初始化拆分器*/
        String str = "apple.banana,,orange,,.";

        List<String> result = Splitter.onPattern("[.|,]").omitEmptyStrings().trimResults().splitToList(str);
        assertEquals(3, result.size());
    }

    @Test
    public void splitStringToListWithFixedLength() {
        /*将字符串分割为元素长度固定的List，最后一个元素长度不足可以直接返回*/
        String str = "Hello world";
        List<String> result = Splitter.fixedLength(3).splitToList(str);

        assertThat(result, contains("Hel", "lo", "wor", "ld"));
    }

    @Test
    public void splitStringToMap() {
        /*String转Map*/
        String str = "John=first,Adam=second";
        Map<String, String> result = Splitter.on(",")
                .withKeyValueSeparator("=")
                .split(str);

        assertEquals("first", result.get("John"));
        assertEquals("second", result.get("Adam"));
    }
}

• CharMatcher

CharMatcher是Guava自定义的匹配器，可以理解为一个CharMatcher实例代表一类字符，可以用于匹配CharSequence中的字符以及对匹配的字符做特定的操作，如修剪[trim]、折叠[collapse]、移除[remove]、保留[retain]等。现在Guava已更新到Guava 25，有很多方法及静态成员变量都已过期。首先罗列一下Guava中已过期不建议使用的方法以及替代方案：

常用方法说明：

示例代码：

public class CharMatcherTest {
    @Test
    public void retainFromTest() {
        String input = "H*el.lo,}12";

        /*以下方法和静态成员变量都已过期，不建议使用
        CharMatcher matcher = CharMatcher.JAVA_LETTER_OR_DIGIT;
        matcher = CharMatcher.javaLetterOrDigit();*/

        /*使用如下初始化*/
        /*CharMatcher matcher = new CharMatcher() {
            @Override
            public boolean matches(char c) {
                return Character.isLetterOrDigit(c);
            }
        };*/

        /*matcher = CharMatcher.forPredicate(Predicates.compose(Predicates.containsPattern("\\w"), Functions.toStringFunction()));*/

        /*Predicate<Character> isLetterOrDigit = new Predicate<Character>() {
            @Override
            public boolean apply(@Nullable Character character) {
                return Character.isLetterOrDigit(character);
            }
        };
        matcher = CharMatcher.forPredicate(isLetterOrDigit);*/

        CharMatcher matcher = CharMatcher.forPredicate(Character::isLetterOrDigit);
        String result = matcher.retainFrom(input);

        assertEquals("Hello12", result);
    }

    @Test
    public void andTest() {
        /*返回两个Matcher执行逻辑与操作的Matcher*/
        String input = "H*el.lo,}12";

        CharMatcher matcher0 = CharMatcher.forPredicate(Character::isLetter);
        CharMatcher matcher1 = CharMatcher.forPredicate(Character::isLowerCase);

        String result = matcher0.and(matcher1).retainFrom(input);
        assertEquals("ello", result);
    }

    @Test
    public void anyTest() {
        /*匹配任意字符*/
        String input = "H*el.lo,}12";
        CharMatcher matcher = CharMatcher.any();

        String result = matcher.retainFrom(input);
        assertEquals("H*el.lo,}12", result);
    }

    @Test
    public void anyOfTest() {
        /*匹配在CharSequence内的任意一个字符*/
        String input = "H*el.lo,}12";
        CharMatcher matcher = CharMatcher.anyOf("Hel");

        String result = matcher.removeFrom(input);
        assertEquals("*.o,}12", result);
    }

    @Test
    public void asciiTest() {
        /*匹配Ascii*/
        String input = "あH*el.lo,}12";
        CharMatcher matcher = CharMatcher.ascii();

        String result = matcher.retainFrom(input);
        assertEquals("H*el.lo,}12", result);
    }

    @Test
    public void breakingWhitespaceTest() {
        /*匹配所有可换行的空白字符，(不包括非换行空白字符,例如"\u00a0")*/
        String input = " this is test ";
        CharMatcher matcher = CharMatcher.breakingWhitespace();

        String result = matcher.removeFrom(input);
        assertEquals("thisistest", result);
    }

    @Test
    public void collapseTest() {
        /*将charMatcher连续被匹配到的字符用一个replacement替换*/
        String input = "       hel    lo      ";

        String result = CharMatcher.is(' ').collapseFrom(input, '-');
        assertEquals("-hel-lo-", result);

        /*先进性Trim操作(讲charSequence头和尾匹配到的连续字符去除)，再进行collapseFrom操作*/
        result = CharMatcher.is(' ').trimAndCollapseFrom(input, '-');
        assertEquals("hel-lo", result);
    }

    @Test
    public void countInTest() {
        /*获取charMatcher匹配到字符的个数*/
        String input = "H*el.lo,}12";
        CharMatcher matcher = CharMatcher.forPredicate(Character::isLetterOrDigit);
        int count = matcher.countIn(input);
        assertEquals(7, count);
    }

    @Test
    public void forPredicateTest() {
        /*通过predicate初始化charMatcher*/
        CharMatcher matcher = CharMatcher.forPredicate(Character::isLetterOrDigit);

        Predicate<Character> isLetterOrDigit = new Predicate<Character>() {
            @Override
            public boolean apply(@Nullable Character character) {
                return Character.isLetterOrDigit(character);
            }
        };
        CharMatcher matcher1 = CharMatcher.forPredicate(isLetterOrDigit);
    }

    @Test
    public void indexInTest() {
        /*获取charMatcher匹配到第一个字符的index*/
        String input = "**el.lo,}12";
        CharMatcher matcher = CharMatcher.forPredicate(Character::isLetterOrDigit);
        int index = matcher.indexIn(input);
        assertEquals(2, index);

        index = matcher.indexIn(input, 4);
        assertEquals(5, index);
    }

    @Test
    public void inRangeTest() {
        /*初始化范围匹配器*/
        String input = "a, c, z, 1, 2";

        int result = CharMatcher.inRange('a', 'h').countIn(input);
        assertEquals(2, result);

    }

    @Test
    public void isTest(){
        /*通过char初始化charMatcher,匹配单个字符*/
        String input = "a, c, z, 1, 2";
        int result = CharMatcher.is(',').countIn(input);
        assertEquals(4, result);
    }

    @Test
    public void isNotTest(){
        /*匹配参数之外的所有字符,与is相反*/
        String input = "a, c, z, 1, 2";
        String result = CharMatcher.isNot(',').removeFrom(input);
        assertEquals(",,,,", result);
    }

    @Test
    public void javaIsoControlTest(){
        /*匹配java转义字符*/
        String input = "ab\tcd\nef\bg";
        String result = CharMatcher.javaIsoControl().removeFrom(input);
        assertEquals("abcdefg", result);
    }

    @Test
    public void lastIndexInTest(){
        /*获取charMatcher匹配到最后一个字符的index*/
        String input = "**e,l.lo,}12";
        CharMatcher matcher = CharMatcher.is(',');
        int index = matcher.lastIndexIn(input);
        assertEquals(8, index);
    }

    @Test
    public void matchesAllOfTest(){
        /*判断CharSequence每一个字符是不是都已被charMatcher匹配*/
        String input = "**e,l.lo,}12";
        CharMatcher matcher = CharMatcher.is(',');
        assertFalse(matcher.matchesAllOf(input));
    }

    @Test
    public void matchesAnyOfTest(){
        /*判断CharSequence是否存在字符被charMatcher匹配*/
        String input = "**e,l.lo,}12";
        CharMatcher matcher = CharMatcher.is(',');
        assertTrue(matcher.matchesAnyOf(input));
    }

    @Test
    public void matchesNoneOfTest(){
        /*判断CharSequence是否每一个字符都没有被charMatcher匹配*/
        String input = "**e,l.lo,}12";
        CharMatcher matcher = CharMatcher.is('?');
        assertTrue(matcher.matchesNoneOf(input));
    }

    @Test
    public void negateTest(){
        /*返回与当前CharMatcher相反的CharMatcher*/
        String input = "あH*el.lo,}12";
        /*charMatcher为非ascii*/
        CharMatcher matcher = CharMatcher.ascii().negate();

        String result = matcher.retainFrom(input);
        assertEquals("あ", result);
    }

    @Test
    public void noneTest(){
        /*不匹配任何字符,与any()相反*/
        String input = "H*el.lo,}12";
        CharMatcher matcher = CharMatcher.none();

        String result = matcher.retainFrom(input);
        assertEquals("", result);
    }

    @Test
    public void noneOfTest(){
        /*不匹配CharSequence内的任意一个字符,与anyOf()相反*/
        String input = "H*el.lo,}12";
        CharMatcher matcher = CharMatcher.noneOf("Hel");

        String result = matcher.removeFrom(input);
        assertEquals("Hell", result);
    }

    @Test
    public void orTest(){
        /*返回两个Matcher执行逻辑或操作的Matcher*/
        String input = "H*el.lo,}12";

        CharMatcher matcher0 = CharMatcher.forPredicate(Character::isLetter);
        CharMatcher matcher1 = CharMatcher.forPredicate(Character::isDigit);

        String result = matcher0.or(matcher1).retainFrom(input);
        assertEquals("Hello12", result);
    }

    @Test
    public void trimFromTest(){
        String input = "---hello,,,";

        /*删除首部匹配到的字符*/
        String result = CharMatcher.is('-').trimLeadingFrom(input);
        assertEquals("hello,,,", result);

        /*删除尾部匹配到的字符*/
        result = CharMatcher.is(',').trimTrailingFrom(input);
        assertEquals("---hello", result);

        /*删除首尾匹配到的字符*/
        result = CharMatcher.anyOf("-,").trimFrom(input);
        assertEquals("hello", result);
    }

    @Test
    public void whitespaceTest(){
        /*匹配所有空白字符*/
        String input = "       hel    lo      ";

        String result = CharMatcher.whitespace().collapseFrom(input, '-');
        assertEquals("-hel-lo-", result);

    }
}

• CaseFormat

CaseFormat格式器，提供不同的ASCII字符格式之间的转换。CaseFormat支持的格式如下：

常用方法：

示例代码：

public class CaseFormatTest {
    @Test
    public void converterToTest(){
        /*返回一个Converter转换器，该转换器会将String按照源格式器转化为targetFormat格式*/
        Converter<String, String> camelConverter = CaseFormat.LOWER_CAMEL.converterTo(CaseFormat.UPPER_UNDERSCORE);
        String input = "input_camel";
        String result = camelConverter.convert(input);
        assertEquals("INPUT_CAMEL", result);
    }

    @Test
    public void toTest(){
        /*将str按照源caseFormat格式转化为目标format格式*/
        String result = CaseFormat.LOWER_HYPHEN.to(CaseFormat.LOWER_CAMEL,"foo-bar");
        assertEquals("fooBar", result);
    }
}