Google Guava

（一）Joiner

import com.google.common.base.Joiner;
import com.google.common.io.Files;
import org.junit.Test;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

import static com.google.common.collect.ImmutableMap.of;
import static java.util.stream.Collectors.joining;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.sameInstance;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.fail;

public class JoinerTest {

    private final List<String> stringList = Arrays.asList(
            "beijing", "shanghai", "guangzhou", "shenzhen", "hangzhou"
    );

    private final List<String> stringListWithNull = Arrays.asList(
            "beijing", "shanghai", "guangzhou", "shenzhen", null
    );

    private final Map<String, String> stringMap = of("beijing", "shanghai", "guangzhou", "shenzhen");

    private final String targetFileName = "E:\txt\guava-joiner.txt";
    private final String targetFileNameToMap = "E:\txt\guava-joiner-map.txt";

    @Test
    public void testJoinOnJoin() {
        //按单个字符拆分
        String result = Joiner.on("#").join(stringList);
        assertThat(result, equalTo("beijing#shanghai#guangzhou#shenzhen#hangzhou"));
    }

    @Test(expected = NullPointerException.class)
    public void testJoinOnJoinWithNull() {
        //按单个字符拆分，遇到null抛出NullPointerException
        String result = Joiner.on("#").join(stringListWithNull);
        assertThat(result, equalTo("beijing#shanghai#guangzhou#shenzhen"));
    }

    @Test
    public void testJoinOnJoinWithNullButSkip() {
        //按单个字符拆分，跳过null
        String result = Joiner.on("#").skipNulls().join(stringListWithNull);
        assertThat(result, equalTo("beijing#shanghai#guangzhou#shenzhen"));
    }

    @Test
    public void testJoinOnJoinWithNullButUseDefaultValue() {
        //按单个字符拆分，用默认值替换null
        String result = Joiner.on("#").useForNull("DEFAULT").join(stringListWithNull);
        assertThat(result, equalTo("beijing#shanghai#guangzhou#shenzhen#DEFAULT"));
    }

    @Test
    public void testJoinOnAppendToStringBuilder() {
        //追加字符，使用每个之间先前配置的分离器
        final StringBuilder builder = new StringBuilder();
        StringBuilder resultBuilder = Joiner.on("#").useForNull("DEFAULT").appendTo(builder, stringListWithNull);
        assertThat(resultBuilder, sameInstance(builder));
        assertThat(resultBuilder.toString(), equalTo("beijing#shanghai#guangzhou#shenzhen#DEFAULT"));
        assertThat(builder.toString(), equalTo("beijing#shanghai#guangzhou#shenzhen#DEFAULT"));
    }

    @Test
    public void testJoinOnAppendToWriter() {
        //追加字符，写入文件
        try (FileWriter writer = new FileWriter(new File(targetFileName))) {
            Joiner.on("#").useForNull("DEFAULT").appendTo(writer, stringListWithNull);
            assertThat(Files.isFile().test(new File(targetFileName)), equalTo(true));
        } catch (IOException e) {
            fail("error.");
        }
    }

    @Test
    public void testJoiningByStreamSkipNull() {
        //分割字符，跳过null
        String result = stringListWithNull.stream()
                .filter(item -> item != null && !item.isEmpty())
                .collect(joining("#"));
        assertThat(result, equalTo("beijing#shanghai#guangzhou#shenzhen"));
    }

    @Test
    public void testJoiningByStreamUseDefaultValue() {
        //分割字符，用默认值替换null
        String result = stringListWithNull.stream()
                //.map(item -> item == null || item.isEmpty() ? "DEFAULT" : item)
                .map(this::defaultValue).collect(joining("#"));
        assertThat(result, equalTo("beijing#shanghai#guangzhou#shenzhen#DEFAULT"));
    }

    private String defaultValue(final String item) {
        return item == null || item.isEmpty() ? "DEFAULT" : item;
    }

    @Test
    public void testJoinOnWitnMap() {
        //指定字符连接map的key value
        String result = Joiner.on("#").withKeyValueSeparator("=").join(stringMap);
        assertThat(result, equalTo("beijing=shanghai#guangzhou=shenzhen"));
    }

    @Test
    public void testJoinOnWitnMapToAppendable() {
        //指定字符连接map的key value，写入文件
        try (FileWriter writer = new FileWriter(new File(targetFileNameToMap))) {
            Joiner.on("#").withKeyValueSeparator("=").appendTo(writer, stringMap);
            assertThat(Files.isFile().test(new File(targetFileNameToMap)), equalTo(true));
        } catch (IOException e) {
            fail("error.");
        }
    }
}

（二）Splitter

import com.google.common.base.Splitter;
import org.junit.Test;

import java.util.List;
import java.util.Map;
import java.util.regex.Pattern;

import static org.hamcrest.core.IsEqual.equalTo;
import static org.hamcrest.core.IsNull.notNullValue;
import static org.junit.Assert.assertThat;

public class SplitterTest {

    @Test
    public void testSplitOnSplit() {
        //用指定字符分割
        List<String> result = Splitter.on("|").splitToList("hello|world");
        assertThat(result, notNullValue());
        assertThat(result.size(), equalTo(2));
        assertThat(result.get(0), equalTo("hello"));
        assertThat(result.get(1), equalTo("world"));
    }

    @Test
    public void testSplitOnSplitOmitEmpty() {
        //用指定字符分割，跳过空
        List<String> result = Splitter.on("|")
                .omitEmptyStrings().splitToList("hello | world||");
        assertThat(result, notNullValue());
        assertThat(result.size(), equalTo(2));
        assertThat(result.get(0), equalTo("hello "));
        assertThat(result.get(1), equalTo(" world"));
    }

    @Test
    public void testSplitOnSplitOmitEmptyTrimResult() {
        //用指定字符分割，去掉分割后前后空格，跳过空
        List<String> result = Splitter.on("|").trimResults()
                .omitEmptyStrings().splitToList("hello|world||");
        assertThat(result, notNullValue());
        assertThat(result.size(), equalTo(2));
        assertThat(result.get(0), equalTo("hello"));
        assertThat(result.get(1), equalTo("world"));
    }

    @Test
    public void testSplitFixLength() {
        //按固定长度拆分，最后一个可能比给定长度短，但不会为空
        List<String> result = Splitter.fixedLength(4).splitToList("aaaabbbbcccc");
        assertThat(result, notNullValue());
        assertThat(result.size(), equalTo(3));
        assertThat(result.get(0), equalTo("aaaa"));
        assertThat(result.get(1), equalTo("bbbb"));
        assertThat(result.get(2), equalTo("cccc"));
    }

    @Test
    public void testSplitOnSplitLimit() {
        //限制拆分出的字符串数量
        List<String> result = Splitter.on("#").limit(2).splitToList("hello#world#java");
        assertThat(result, notNullValue());
        assertThat(result.size(), equalTo(2));
        assertThat(result.get(0), equalTo("hello"));
        assertThat(result.get(1), equalTo("world#java"));
    }

    @Test
    public void testSplitOnPatternString() {
        //按正则拆分，传入正则字符串
        List<String> result = Splitter.onPattern("\|").trimResults()
                .omitEmptyStrings().splitToList("hello | world|||java");
        assertThat(result, notNullValue());
        assertThat(result.size(), equalTo(3));
        assertThat(result.get(0), equalTo("hello"));
        assertThat(result.get(1), equalTo("world"));
        assertThat(result.get(2), equalTo("java"));
    }

    @Test
    public void testSplitOnPattern() {
        //按正则拆分，传入正则
        List<String> result = Splitter.on(Pattern.compile("\|")).
                trimResults().omitEmptyStrings().splitToList("hello | world|||java");
        assertThat(result, notNullValue());
        assertThat(result.size(), equalTo(3));
        assertThat(result.get(0), equalTo("hello"));
        assertThat(result.get(1), equalTo("world"));
        assertThat(result.get(2), equalTo("java"));
    }

    @Test
    public void testSplitOnSplitToMap() {
        //按连接符拆成map
        Map<String, String> result = Splitter.on(Pattern.compile("\|")).trimResults().omitEmptyStrings()
                .withKeyValueSeparator("=").split("hello=HELLO | world=WORLD||");
        assertThat(result, notNullValue());
        assertThat(result.size(), equalTo(2));
        assertThat(result.get("hello"), equalTo("HELLO"));
        assertThat(result.get("world"), equalTo("WORLD"));
    }
}

（三）Strings

//空字符串变为null
System.out.println(Strings.emptyToNull("")); //null

//null变为空字符串
System.out.println(Strings.nullToEmpty(null)); //""
System.out.println(Strings.nullToEmpty("hello")); //hello

//取相同前缀
System.out.println(Strings.commonPrefix("Hello", "Hit")); //H
System.out.println(Strings.commonPrefix("Hello", "Xit")); //""

//取相同后缀
System.out.println(Strings.commonSuffix("Hello", "Echo")); //o

//字符串成倍数输出
System.out.println(Strings.repeat("Alex", 3)); //AlexAlexAlex

//判断是null或空
System.out.println(Strings.isNullOrEmpty(null)); //true
System.out.println(Strings.isNullOrEmpty("")); //true

//指定最小长度，不够用指定字符在前面添加
System.out.println(Strings.padStart("Alex", 3, 'H'));
System.out.println(Strings.padStart("Alex", 5, 'H')); //HAlex
//指定最小长度，不够用指定字符在后面添加
System.out.println(Strings.padEnd("Alex", 5, 'H')); //AlexH

（四）Charsets

//获取字符集编码
Charset charset = Charset.forName("UTF-8");
System.out.println(Charsets.UTF_8 == charset); //true

（五）CharMatcher

//判断是否是数字
System.out.println(CharMatcher.javaDigit().matches('5')); //true
System.out.println(CharMatcher.javaDigit().matches('a')); //false

//统计含有字符的个数
System.out.println(CharMatcher.is('A').countIn("AaaaAbbb")); //2

//用指定字符替换空格，连续多个空格去重，返回原始
System.out.println(CharMatcher.breakingWhitespace().collapseFrom("   aa bb  ", '*')); //*aa*bb*

//用指定字符替换数字，返回副本，返回副本
System.out.println(CharMatcher.javaDigit().replaceFrom("abc  123abc", "*")); //abc  ***abc

//移除指定字符
System.out.println(CharMatcher.javaDigit().or(CharMatcher.whitespace()).removeFrom("aaa 111 bbb")); //aaabbb

//除指定字符外全部移除
System.out.println(CharMatcher.javaDigit().or(CharMatcher.whitespace()).retainFrom("aaa 111 bbb")); // 111

//用指定字符替换空格，连续多个空格去重，返回原始
System.out.println(CharMatcher.whitespace().trimAndCollapseFrom("   aa bb   cc", ' ')); //aa bb cc

（六）CaseFormat

//指定字符串格式转换
//lower-hyphen变为lowerCamel
System.out.println(CaseFormat.LOWER_HYPHEN.to(CaseFormat.LOWER_CAMEL, "test-data")); //testData
//lower_underscore变为lowerCamel
System.out.println(CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, "test_data")); //testData
//lower_underscore变为UpperCamel
System.out.println(CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL, "test_data")); //TestData