Forwarding裝飾器

針對所有類型的集合接口，Guava都提供了Forwarding抽象類以簡化裝飾者模式的使用。

Forwarding抽象類定義了一個抽象方法：delegate()，你可以覆蓋這個方法來返回被裝飾對象。所有其他方法都會直接委托給delegate()。例如說：ForwardingList.get(int)實際上執行了delegate().get(int)。

通過創建ForwardingXXX的子類並實現delegate()方法，可以選擇性地覆蓋子類的方法來增加裝飾功能，而不需要自己委托每個方法——譯者註：因為所有方法都默認委托給delegate()返回的對象，你可以只覆蓋需要裝飾的方法。

讓我們看看這個例子。假定你想裝飾一個List，讓其記錄所有添加進來的元素。當然，無論元素是用什麽方法——add(int, E), add(E), 或addAll(Collection)——添加進來的，我們都希望進行記錄，因此我們需要覆蓋所有這些方法。

class
 
 AddLoggingList<E> extends ForwardingList<E> {
    final List<E> delegate; // backing list
    @Override protected List<E> delegate() {
        return delegate;
    }
    @Override public void add(int index, E elem) {
        log(index, elem);
        super.add(index, elem);
    }
    @Override 
 
public boolean add(E elem) {
        return standardAdd(elem); // 用add(int, E)實現
    }
    @Override public boolean addAll(Collection<? extends E> c) {
        return standardAddAll(c); // 用add實現
    }
}

記住，默認情況下，所有方法都直接轉發到被代理對象，因此覆蓋ForwardingMap.put並不會改變ForwardingMap.putAll的行為。小心覆蓋所有需要改變行為的方法，並且確保裝飾後的集合滿足接口契約。

通常來說，類似於AbstractList的抽象集合骨架類，其大多數方法在Forwarding裝飾器中都有對應的”標準方法”實現。

對提供特定視圖的接口，Forwarding裝飾器也為這些視圖提供了相應的”標準方法”實現。例如，ForwardingMap提供StandardKeySet、StandardValues和StandardEntrySet類，它們在可以的情況下都會把自己的方法委托給被裝飾的Map，把不能委托的聲明為抽象方法。

PeekingIterator

有時候，普通的Iterator接口還不夠。

Iterators提供一個Iterators.peekingIterator(Iterator)方法，來把Iterator包裝為PeekingIterator，這是Iterator的子類，它能讓你事先窺視[peek()]到下一次調用next()返回的元素。

註意：Iterators.peekingIterator返回的PeekingIterator不支持在peek()操作之後調用remove()方法。

舉個例子：復制一個List，並去除連續的重復元素。

List<E> result = Lists.newArrayList();
PeekingIterator<E> iter = Iterators.peekingIterator(source.iterator());
while (iter.hasNext()) {
    E current = iter.next();
    while (iter.hasNext() && iter.peek().equals(current)) {
        //跳過重復的元素
        iter.next();
    }
    result.add(current);
}

傳統的實現方式需要記錄上一個元素，並在特定情況下後退，但這很難處理且容易出錯。相較而言，PeekingIterator在理解和使用上就比較直接了。

AbstractIterator

實現你自己的Iterator？AbstractIterator讓生活更輕松。

用一個例子來解釋AbstractIterator最簡單。比方說，我們要包裝一個iterator以跳過空值。

public static Iterator<String> skipNulls(final Iterator<String> in) {
    return new AbstractIterator<String>() {
        protected String computeNext() {
            while (in.hasNext()) {
                String s = in.next();
                if (s != null) {
                    return s;
                }
            }
            return endOfData();
        }
    };
}

你實現了computeNext()方法，來計算下一個值。如果循環結束了也沒有找到下一個值，請返回endOfData()表明已經到達叠代的末尾。

註意：AbstractIterator繼承了UnmodifiableIterator，所以禁止實現remove()方法。如果你需要支持remove()的叠代器，就不應該繼承AbstractIterator。

AbstractSequentialIterator

有一些叠代器用其他方式表示會更簡單。AbstractSequentialIterator 就提供了表示叠代的另一種方式。

Iterator<Integer> powersOfTwo = new AbstractSequentialIterator<Integer>(1) { // 註意初始值1!
    protected Integer computeNext(Integer previous) {
        return (previous == 1 << 30) ? null : previous * 2;
    }
};

我們在這兒實現了computeNext(T)方法，它能接受前一個值作為參數。

註意，你必須額外傳入一個初始值，或者傳入null讓叠代立即結束。因為computeNext(T)假定null值意味著叠代的末尾——AbstractSequentialIterator不能用來實現可能返回null的叠代器。

集合-集合擴展工具類