钩子函数 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 为钩子函数。

转载于:https://www.cnblogs.com/wzhanke/p/4778026.html