[Guava源码日报]（3）Joiner分析

把任意的字符串，通过一些分隔符将它们连接起来是大多数程序员经常处理东西。以前的方式就是迭代，append等操作，使用Joiner可以更方便。

我们先看一下以前的处理方式：

// 通过分隔符将字符串链接在一起    public static  String builder(List<String> list,String delimiter){        StringBuilder stringBuilder = new StringBuilder();        for(String str : list){            if(str != null){                stringBuilder.append(str).append(delimiter);            }//if        }//for        stringBuilder.setLength(stringBuilder.length() - delimiter.length());        return stringBuilder.toString();    }

这样操作显得比较麻烦，为此Joiner为我们提供了很好的解决方法。

举例：

package com.qunar.guava.joiner;import com.google.common.base.Joiner;import java.util.ArrayList;import java.util.HashMap;import java.util.List;/** * Created by xiaosi on 16-3-2. */public class Test {    private static List<String> list = new ArrayList<String>();    private static String delimiter = "---";    public static void main(String[] args) {        list.add("apple");        list.add("banana");        list.add(null);        list.add("pear");        test1();        test2();        test3();        test4();        test5();        test6();    }    // 通过分隔符将字符串链接在一起    public static  String builder(List<String> list,String delimiter){        StringBuilder stringBuilder = new StringBuilder();        for(String str : list){            if(str != null){                stringBuilder.append(str).append(delimiter);            }//if        }//for        stringBuilder.setLength(stringBuilder.length() - delimiter.length());        return stringBuilder.toString();    }    public static  void test1(){        System.out.println("test1：" + builder(list,delimiter));    }    // skipNulls    public static  void test2(){        Joiner joiner = Joiner.on(delimiter);        String excludeNUllString = joiner.skipNulls().join(list);        System.out.println("test2：" + excludeNUllString);    }    // useForNull    public static  void test3(){        Joiner joiner = Joiner.on(delimiter);        String str = joiner.useForNull("invalid fruit").join(list);        System.out.println("test3：" + str);    }    // passing a StringBuilder instance to the Joiner class and the StringBuilder object is returned.    public static  void test4(){        Joiner joiner = Joiner.on(delimiter);        StringBuilder stringBuilder = new StringBuilder("   fruit：");        joiner.skipNulls().appendTo(stringBuilder,list);        System.out.println("test4：" + stringBuilder.toString());    }    // map    public static  void test5(){        HashMap<String,Float> map = new HashMap<String, Float>();        map.put("apple",5.6F);        map.put("pear",4.5F);        map.put("banana",7.8F);        Joiner.MapJoiner mapJoiner = Joiner.on(",").withKeyValueSeparator("=");        String str = mapJoiner.join(map);        System.out.println("test5：" + str);    }    // 错误方法    public static void test6(){        Joiner joiner = Joiner.on(delimiter);        String str = joiner.useForNull("invalid fruit").useForNull(".....").join(list);        System.out.println("test6：" + str);    }}

运行结果：

test1：apple---banana---peartest2：apple---banana---peartest3：apple---banana---invalid fruit---peartest4：   fruit：apple---banana---peartest5：banana=7.8,apple=5.6,pear=4.5Exception in thread "main" java.lang.UnsupportedOperationException: already specified useForNullat com.google.common.base.Joiner$1.useForNull(Joiner.java:233)at com.qunar.guava.joiner.Test.test6(Test.java:76)at com.qunar.guava.joiner.Test.main(Test.java:27)at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)at java.lang.reflect.Method.invoke(Method.java:606)at com.intellij.rt.execution.application.AppMain.main(AppMain.java:134)

2. 源码分析

2.1 构造器

/** 字符串分隔符构造Joiner对象* @param separator 字符串分隔符*/private Joiner(String separator) {    this.separator = checkNotNull(separator);}/** * 使用Joiner对象构造Joiner对象 * @param prototype Joiner对象*/private Joiner(Joiner prototype) {    this.separator = prototype.separator;}

这里构造器都是private级别的，所以我们自己不能直接使用new创建Joiner对象，这里的构造器是为类中其他方法提供的。

2.2 设置分隔符

这里有两种方式设置分隔符，一种给它传递一个字符串形式的分隔符，另一种是给它传递字符形式的分隔符

/**     * 设置分隔符     * @param separator 分隔符（字符串）     * @return 返回Joiner对象     */    public static Joiner on(String separator) {        return new Joiner(separator);    }    /**     * 设置分隔符     * @param separator 分隔符（字符）     * @return     */    public static Joiner on(char separator) {        // 使用字符转换未字符串        return new Joiner(String.valueOf(separator));    }

在这我们就用到了上面所说的私有构造器。

2.3 toString方法

/**     * 转换为字符序列     * @param part Object对象     * @return 返回字符序列     */    CharSequence toString(Object part) {        // 先决条件 判断是否为null        checkNotNull(part);        // 如果part是CharSequence类型的实例对象则返回CharSequence对象 否则转换为String类型返回        return (part instanceof CharSequence) ? (CharSequence) part : part.toString();    }

如果part是CharSequence类型的实例对象则返回CharSequence对象 否则转换为String类型返回。

备注：

CharSequence是一个接口，它只包括length(), charAt(int index), subSequence(int start, int end)这几个API接口。除了String实现了CharSequence之外，StringBuffer和StringBuilder也实现了CharSequence接口。

2.4 useForNull

用给定的字符串替换出现的null值。它是通过返回一个覆盖了方法的 Joiner 实例来实现的。

/**     * 使用nullText代替出现的null     * @param nullText 替换的字符串     * @return 返回替换后的一个新对象     */@CheckReturnValue    public Joiner useForNull(final String nullText) {        // 先决条件 判断是否为null        checkNotNull(nullText);        // 使用内部类返回Joiner对象        return new Joiner(this) {            // 重写一下几个方法            @Override            // 如果参数为null，则用nullText代替返回，否则转换为字符序列直接返回            CharSequence toString(@Nullable Object part) {                return (part == null) ? nullText : Joiner.this.toString(part);            }            @Override            // 第一次调用useForNull会返回一个新对象，再次调用useForNull时则是调用这个内部类中的方法，抛出异常            public Joiner useForNull(String nullText) {                throw new UnsupportedOperationException("already specified useForNull");            }            @Override            // 第一次调用useForNull会返回一个新对象，再次调用skipNulls时则是调用这个内部类中的方法，抛出异常            public Joiner skipNulls() {                throw new UnsupportedOperationException("already specified useForNull");            }        };    }

使用useForNull方法，会产生一个新的Joiner对象，并且重写了toString()，useForNull()和SkipNulls()方法。所以再次调用以上几个方法时，不是调用的Joiner原始方法，而是调用返回的内部类重写的方法。为了防止重复调用 useForNull 和 skipNulls，还特意覆盖了这两个方法，一旦调用就抛出运行时异常。为什么不能重复调用 useForNull ？因为覆盖了 toString 方法，而覆盖实现中需要调用覆盖前的 toString。

我们举个例子：

public static void test6(){        Joiner joiner = Joiner.on(delimiter);        String str = joiner.useForNull("invalid fruit").useForNull(".....").join(list);        System.out.println("test6：" + str);}

我们连续调用两次useForNull()方法，则会抛出内部类中定义的UnsupportedOperationException，并且提示already specified useForNull错误信息。我们想想也就明白，我们都已经用useForNull方法处理null了，再次调用useForNull()和skipNulls()方法已经没有任何意义，所以重新返回一个对象，并重新这几个方法。

2.5 appendTo(A appendable,Iterator<?> parts)

对parts进行分割并使用分隔符进行连接，最后添加到appendable内容后。

只要实现了Appendable接口的实现类都可以使用appendTo方法。

// A是继承Appendable接口的一个接口    public <A extends Appendable> A appendTo(A appendable, Iterator<?> parts) throws IOException {        checkNotNull(appendable);        // 遍历迭代器        if (parts.hasNext()) {            // 添加到appendable后面            appendable.append(toString(parts.next()));            // 遍历迭代器            while (parts.hasNext()) {                // 使用分隔符分割                appendable.append(separator);                // 添加到appendable后面                appendable.append(toString(parts.next()));            }        }        return appendable;    }

2.6 skipNulls

跳过null值，不用处理，如果向处理过程中的null值，可以使用useForNull方法处理null值。

@CheckReturnValue    public Joiner skipNulls() {        // 使用内部类返回Joiner对象        return new Joiner(this) {            @Override            public <A extends Appendable> A appendTo(A appendable, Iterator<?> parts) throws IOException {                checkNotNull(appendable, "appendable");                checkNotNull(parts, "parts");                // 找到第一个不为null的Object对象                while (parts.hasNext()) {                    Object part = parts.next();                    if (part != null) {                        appendable.append(Joiner.this.toString(part));                        break;                    }                }                // 使用分隔符连接，并添加到appendable实现类内容末尾                while (parts.hasNext()) {                    Object part = parts.next();                    if (part != null) {                        appendable.append(separator);                        appendable.append(Joiner.this.toString(part));                    }                }                return appendable;            }            @Override            // 第一次调用skipNulls会返回一个新对象，再次调用useForNull时则是调用这个内部类中的方法，抛出异常            public Joiner useForNull(String nullText) {                throw new UnsupportedOperationException("already specified skipNulls");            }            @Override            // 第一次调用skipNulls会返回一个新对象，再次调用withKeyValueSeparator时则是调用这个内部类中的方法，抛出异常            public MapJoiner withKeyValueSeparator(String kvs) {                throw new UnsupportedOperationException("can't use .skipNulls() with maps");            }        };    }

2.7 拼接键值对

MapJoiner 实现为 Joiner 的一个静态内部类，它的构造函数和 Joiner 一样也是私有，只能通过 Joiner#withKeyValueSeparator 来生成实例。类似地，MapJoiner 也实现了 appendTo 方法和一系列的重载，还用 join 方法对 appendTo 做了封装。MapJoiner 整个实现和 Joiner 大同小异，在实现中大量 Joiner 的 toString 方法来保证空指针保护行为和初始化时的语义一致。

MapJoiner 也实现了一个 useForNull 方法，这样的好处是，在获取 MapJoiner 之后再去设置空指针保护，和获取 MapJoiner 之前就设置空指针保护，是等价的，用户无需去关心顺序问题。