Java效率提升神器之Guava-Joiner怎么使用

今天小編給大家分享一下Java效率提升神器之Guava-Joiner怎么使用的相關知識點，內容詳細，邏輯清晰，相信大部分人都還太了解這方面的知識，所以分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后有所收獲，下面我們一起來了解一下吧。

Joiner

這是在我們代碼中出現頻率比較高的一個功能。經常需要將幾個字符串，或者字符串數組、列表之類的東西，拼接成一個以指定符號分隔各個元素的字符串，比如要將一個用List保存的字符集合拼起來作為SQL語句的條件，在知道Joiner之前我們會這樣做。

ArrayList<String> conditions = new ArrayList<String>();
conditions.add("condition1");
conditions.add("condition2");
conditions.add("condition3");

private String buildCondition(ArrayList<String> conditions) {
    StringBuilder sb = new StringBuilder();
    for (String condition : conditions) {
        sb.append(condition);
        sb.append(" or ");
    }
    int index = sb.lastIndexOf(" or ");
    return index > 0 ? sb.substring(0, index) : sb.toString();
}  // condition1 or condition2 or condition3

基本上會手寫循環去實現，代碼瞬間變得丑陋起來。并且循環完了還得刪除最后一個多余的or。

使用Guava工具，我們能夠輕而易舉的完成字符串拼接這一簡單任務。借助 Joiner 類，代碼瞬間變得優雅起來。

Joiner.on(" or ").join(conditions);

被拼接的對象集，可以是硬編碼的少數幾個對象，可以是實現了 Iterable 接口的集合，也可以是迭代器對象。

除了返回一個拼接過的字符串，Joiner 還可以在實現了 Appendable 接口的對象所維護的內容的末尾，追加字符串拼接的結果。

StringBuilder sb = new StringBuilder("result:");
Joiner.on("＃").appendTo(sb, 1, 2, 3);
System.out.println(sb);     //result:1＃2＃3

我們看下面這個例子：

Joiner.on("#").join(1, null, 3)

如果傳入的對象中包含空指針，會直接拋出空指針異常。Joiner 提供了兩個方法，讓我們能夠優雅的處理待拼接集合中的空指針。

如果我們希望忽略空指針，那么可以調用 skipNulls方法，得到一個會跳過空指針的 Joiner 實例。如果希望將空指針變為某個指定的值，那么可以調用 useForNull 方法，指定用來替換空指針的字符串。

Joiner.on("#").skipNulls().join(1, null, 3);      //1#3
Joiner.on("#").useForNull("").join(1, null, 3);   //1##3

Joiner.MapJoiner

MapJoiner 是 Joiner 的內部靜態類，用于幫助將 Map 對象拼接成字符串。

 Map<Integer, Integer> test = new HashMap<Integer, Integer>();
 test.put(1, 2);
 test.put(3, 4);
 Joiner.on("#").withKeyValueSeparator("=").join(test); //1=2#3=4

withKeyValueSeparator 方法指定了鍵與值的分隔符，同時返回一個 MapJoiner 實例。

Joiner.on("#").withKeyValueSeparator("=").join(ImmutableMap.of(1, 2, 3, 4));  //1=2#3=4

源代碼分析

源碼來自Guava 18.0。Joiner類的源碼一共458行。大部分都是注釋。 Joiner 只能通過 Joiner.on 函數來初始化，它的構造方法是私有的。

/**
* Returns a joiner which automatically places {@code separator} between consecutive elements.
*/
public static Joiner on(String separator) {
	return new Joiner(separator);
}
/**
* Returns a joiner which automatically places {@code separator} between consecutive elements.
*/
public static Joiner on(char separator) {
	return new Joiner(String.valueOf(separator));
}

整個 Joiner 類最核心的函數莫過于 <A extends Appendable> appendTo(A, Iterator<?>)，一切的字符串拼接操作，最后都會調用到這個函數。這就是所謂的全功能函數，其他的一切 appendTo 只不過是它的重載，一切的join不過是它和它的重載的封裝。

/**
   * Appends the string representation of each of {@code parts}, using the previously configured
   * separator between each, to {@code appendable}.
   *
   * @since 11.0
   */
  public <A extends Appendable> A appendTo(A appendable, Iterator<?> parts) throws IOException {
    checkNotNull(appendable);
    if (parts.hasNext()) {
      appendable.append(toString(parts.next()));
      while (parts.hasNext()) {
        appendable.append(separator);
        appendable.append(toString(parts.next()));
      }
    }
    return appendable;
  }

這段代碼的第一個技巧是使用 if 和 while 來實現了比較優雅的分隔符拼接，避免了在末尾插入分隔符的尷尬；第二個技巧是使用了自定義的 toString 方法而不是 Object#toString 來將對象序列化成字符串，為后續的各種空指針保護開了方便之門。

來看一個比較有意思的 appendTo 重載。

public final StringBuilder appendTo(StringBuilder builder, Iterator<?> parts) {
    try {
        this.appendTo((Appendable)builder, (Iterator)parts);
        return builder;
    } catch (IOException var4) {
        throw new AssertionError(var4);
    }
}

在 Appendable 接口中，append 方法是會拋出 IOException 的。然而 StringBuilder 雖然實現了 Appendable，但是它覆蓋實現的 append 方法卻是不拋出 IOException 的。于是就出現了明知不可能拋異常，卻又不得不去捕獲異常的尷尬。

這里的異常處理手法十分機智，異常變量命名為 impossible，我們一看就明白這里是不會拋出 IOException 的。但是如果 catch 塊里面什么都不做又好像不合適，于是拋出一個 AssertionError，表示對于這里不拋異常的斷言失敗了。

另一個比較有意思的 appendTo 重載是關于可變長參數。

public final <A extends Appendable> A appendTo(A appendable, @Nullable Object first, @Nullable Object second, Object... rest) throws IOException {
    return this.appendTo((Appendable)appendable, (Iterable)iterable(first, second, rest));
}

注意到這里的 iterable 方法，它把兩個變量和一個數組變成了一個實現了Iterable 接口的集合，非常精妙的實現！

private static Iterable<Object> iterable(final Object first, final Object second, final Object[] rest) {
    Preconditions.checkNotNull(rest);
    return new AbstractList() {
        public int size() {
            return rest.length + 2;
        }
        public Object get(int index) {
            switch(index) {
            case 0:
                return first;
            case 1:
                return second;
            default:
                return rest[index - 2];
            }
        }
    };
}

要想看明白這段代碼，需要熟悉AbstractList類中迭代器的實現。迭代器內部維護著一個游標，cursor。迭代器的兩大關鍵操作，hasNext 判斷是否還有沒遍歷的元素，next 獲取下一個元素，它們的實現是這樣的。

public boolean hasNext() {
        return cursor != size();
}
public E next() {
        checkForComodification();
    try {
    E next = get(cursor);
    lastRet = cursor++;
    return next;
    } catch (IndexOutOfBoundsException e) {
    checkForComodification();
    throw new NoSuchElementException();
    }
}

hasNext 中關鍵的函數調用是size方法，獲取集合的大小。next 方法中關鍵的函數調用是get方法，獲取第 i 個元素。Guava 的實現返回了一個被覆蓋了 size 和 get 方法的 AbstractList，巧妙的復用了由編譯器生成的數組，避免了新建列表和增加元素的開銷。

拼接Map鍵值對

MapJoiner 實現為 Joiner 的一個靜態內部類，它的構造函數和 Joiner 一樣也是私有，只能通過 withKeyValueSeparator來生成實例。類似地，MapJoiner 也實現了 appendTo 方法和一系列的重載，還用 join 方法對 appendTo 做了封裝。

MapJoiner 整個實現和 Joiner 大同小異，在實現中大量使用 Joiner 的 toString 方法來保證空指針保護行為和初始化時的語義一致。

以上就是“Java效率提升神器之Guava-Joiner怎么使用”這篇文章的所有內容，感謝各位的閱讀！相信大家閱讀完這篇文章都有很大的收獲，小編每天都會為大家更新不同的知識，如果還想學習更多的知識，請關注億速云行業資訊頻道。