Guava-Function&Predicate

• guava函数式编程体现在Function和Predicate两个接口上。
  Function用于转换对象 （根据输入决定输出）
  Predicate用于过滤对象（判断是否满足条件）

• Collection内部用了比较多的Function和Predicate

• Lists.transform 不同类型变量list转换

• Iterables.tryFind 获取符合条件的元素

需要注意：
Lists.transform返回结果不能add，在原来的List上增加就可以了
dubbo不支持Guava中List的反序列化（必须要有公有的构造方法），但是

使用例子

    @Test
    public void functionalTest() throws Exception {
        Function<Integer, String> intToString = new Function<Integer, String>() {
            @Override
            public String apply(Integer input) {
                if(input==null) {
                    return null;
                }
                return ">"+input+"<";
            }
        };

        List<Integer> intList = Lists.newArrayList(1, 2, 3);
        List<String> stringList = Lists.transform(intList, intToString);
        System.out.println(stringList);
    }

    @Test
    public void predicate() {
        Predicate<Integer> greaterThan5 = new Predicate<Integer>() {
            @Override
            public boolean apply(Integer input) {
                return input==null?false:input<5;
            }
        };
        List<Integer> intList = Lists.newArrayList(1, 2, 7);
        Iterable<Integer> filter = Iterables.filter(intList, greaterThan5);
        for (Integer integer : filter) {
            System.out.println(integer);
        }
    }

Lists.transform中transform

  public static <F, T> List<T> transform(
      List<F> fromList, Function<? super F, ? extends T> function) {
    return (fromList instanceof RandomAccess)
        ? new TransformingRandomAccessList<F, T>(fromList, function)
        : new TransformingSequentialList<F, T>(fromList, function);
  }

TransformingRandomAccessList的get方法
  @Override public T get(int index) {
      return function.apply(fromList.get(index));
    }

TransformingSequentialList继承AbstractSequentialList
其get方法是调用迭代器的next，迭代器被覆盖了
  @Override public ListIterator<T> listIterator(final int index) {
      return new TransformedListIterator<F, T>(fromList.listIterator(index)) {
        @Override
        T transform(F from) {
          return function.apply(from);
        }
      };
    }

Iterables.filter中的Predicate

  public static <T> Iterable<T> filter(
      final Iterable<T> unfiltered, final Predicate<? super T> predicate) {
    checkNotNull(unfiltered);
    checkNotNull(predicate);
    return new FluentIterable<T>() {
      @Override
      public Iterator<T> iterator() {
        return Iterators.filter(unfiltered.iterator(), predicate);
      }
    };
  }

 public static <T> UnmodifiableIterator<T> filter(
      final Iterator<T> unfiltered, final Predicate<? super T> predicate) {
    checkNotNull(unfiltered);
    checkNotNull(predicate);
    return new AbstractIterator<T>() {
      @Override protected T computeNext() {
        while (unfiltered.hasNext()) {
          T element = unfiltered.next();
          if (predicate.apply(element)) {
            return element;
          }
        }
        return endOfData();
      }
    };
  }