把任意的字符串，通过一些分隔符将它们连接起来是大多数程序员经常处理东西。以前的方式就是迭代，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 之前就设置空指针保护，是等价的，用户无需去关心顺序问题。