鉤子函數 Function類

Function 爲

com.google.common.base包下接口類：

public interface Function<F, T> {

    @Nullable T apply(@Nullable F input);

    @Override
    boolean equals(@Nullable Object object);

}

鉤子函數用法：

public void backFunc（Function<F,T> func）{

　　F  f = new F();

　　T t =  func.apply(f);

　　-- 就獲得了想要的T對象了。。。

}

調用鉤子函數：

backFunc(   new Function<F,T>() {    public T apply(F f){ return  處理f獲得T對象邏輯}      }      );

 

例子：

Iterable<String> iter = Splitter.on(",").split("1,2,3");
        Iterator<Integer> its = Iterators.transform(iter.iterator(), new Function<String, Integer>() {
            @Override
            public Integer apply(String input) {
                int roleid = Integer.parseInt(input);
                return roleid;
            }
        });
        ArrayList<Integer> list = Lists.newArrayList(its);
        Iterator<Integer> iterator = list.iterator();
        System.out.println("roleidList = " + integers);

Iterators.transform()  方法 內容：

public static <F, T> Iterator<T> transform(final Iterator<F> fromIterator,
      final Function<? super F, ? extends T> function) {
    checkNotNull(function);
    return new TransformedIterator<F, T>(fromIterator) {
      @Override
      T transform(F from) {
        return function.apply(from);
      }
    };
  }

TransformedIterator 類：

abstract class TransformedIterator<F, T> implements Iterator<T> {
  final Iterator<? extends F> backingIterator;

  TransformedIterator(Iterator<? extends F> backingIterator) {
    this.backingIterator = checkNotNull(backingIterator);
  }

  abstract T transform(F from);

  @Override
  public final boolean hasNext() {
    return backingIterator.hasNext();
  }

  @Override
  public final T next() {
    return transform(backingIterator.next());
  }

  @Override
  public final void remove() {
    backingIterator.remove();
  }
}

上邊代碼解析：

要想把分割"1,2,3"  獲得的List<String> 轉化 爲 List<Integer>  , 上邊首先 利用 google 包下的 Iterators.transform() 方法，這個方法返回TransformedIterator對象，此對象 類是一個抽象類，其中transform爲抽象未實現方法，能夠利用這個特性進行回調設計，而此類中 next 方法 恰好就調用此抽象接口方法，剛哈就完成了回調操做，而因爲next方法只會在 遍歷 迭代器時纔會調用，因此 上邊代碼 讓人疑惑的是 循環迭代 是在什麼位置 開始的，其實 上邊代碼中 迭代 是在 ArrayList<Integer> list = Lists.newArrayList(its);  這句代碼纔開始循環迭代，也就是說 這句代碼上邊的 Iterator<Integer> its 對象 其實僅僅是 Iterators.transform()  方法 中剛new的TransformedIterator 對象，這個剛new的TransformedIterator對象 僅僅作了實現transform抽象方法的操做，其餘什麼操做都沒有作，也就是這個時候根本就尚未迭代，就是說 此 返回給Iterator<Integer> its 對象僅僅是一個 新new的 尚未作實際操做的 TransformedIterator 對象，也就是 List<String> 尚未開始 轉換 成List<Integer>,真正 開始轉換的是 迭代器真正調用迭代器 next() 的時候，而 ArrayList<Integer> list = Lists.newArrayList(its);   這句代碼其實 就調用 list的 addAll方法，參數 是迭代器，結果就是迭代器調用next方法 一個一個的將迭代器元素 加入到list中的，也就是說 將 List<String>轉換 成List<Integer>是從Lists.newArrayList(its) 這裏開始轉換的。

說明： 上邊的例子中涉及不單單一處鉤子回調函數，上邊涉及了2處鉤子函數，一個是 TransformedIterator tranfrom抽象方法 由迭代器 next方法回調，此next即爲鉤子函數。還一處 是Function 的 apply方法由 TransformedIterator 實現後的 tranfrom 方法 回調，此 tranform 爲鉤子函數。