Guava 是个风火轮之函数式编程(3)——表处理

最新推荐文章于 2022-07-15 21:22:58 发布

ditong7882

最新推荐文章于 2022-07-15 21:22:58 发布

阅读量96

点赞数

文章标签： java python

原文链接：http://www.cnblogs.com/jobs-lgy/p/6216539.html

版权

Guava 是个风火轮之函数式编程(3)——表处理

潘家邦 2016-01-26 13:19:21 浏览1062 评论0

java Guava

摘要： 早先学习 Scheme 的时候，就已经对 Lisp 那行云流水般的表处理手段一见倾心。后来使用 Python 做数据处理时，语言内置的高阶函数更是得心应手。工作之后开始使用 Java，一开始的时候仿佛回到了石器时代。直到后来我找到了 Guava，才终于又可以使用熟悉的方式去操纵集合。函数式风格...

早先学习 Scheme 的时候，就已经对 Lisp 那行云流水般的表处理手段一见倾心。后来使用 Python 做数据处理时，语言内置的高阶函数更是得心应手。工作之后开始使用 Java，一开始的时候仿佛回到了石器时代。

直到后来我找到了 Guava，才终于又可以使用熟悉的方式去操纵集合。

函数式风格的表处理让开发者从底层的迭代处理中解放出来，从更加抽象的层面来思考问题。然而，Guava 仅仅实现了 map、filter 者两个高阶函数，并没有实现 reduce。

映射

表处理中有这样一个操作，将某个函数分别应用到集合的每个元素上，将返回值集合以列表返回，这个操作一般命名为 map，实现为一个高阶函数。

在 Guava 中，提供同样操作的方法是一个静态函数，Collections2#transform。按照 map 函数的约定俗成，第一个参数是被操作集合，第二个参数是操作函数，返回值是结果集合。也许是出于避免函数名和变量名冲突的考虑，Guava 没有像其他语言那样使用 map 作为函数名，而是使用了 transform。（想想我们写的生产代码里面有多少个哈希表以 map 命名，回去面壁……）

Function<Integer, Integer> square = new Function<Integer, Integer>() {
    public Integer apply(Integer input) {
        return input * input;
    }
};
Collections2.transform(Lists.newArrayList(1, 2, 3), square);//[1, 4, 9]

过滤

高阶函数 filter 的作用和它的名字一样，就是个过滤器，将一个布尔型函数应用到集合的每个元素上，然后根据函数的返回值决定元素是否留在返回值集合中。

在 Guava 中，Collections2#filter 提供了 filter 的功能。这一次 Guava 使用了约定俗成的名字。

Predicate<Integer> isOdd = new Predicate<Integer>() {
    public boolean apply(Integer input) {
        return (input & 1) != 0;
    }
};
Collections2.filter(Lists.newArrayList(1, 2, 3), isOdd);//[1, 3]

折叠

折叠这个操作是把一个列表归并成一个元素，在一些语言中这个操作被称作 fold，另一些称之为 reduce。

在 Python 中，我们假如我们想要实现列表元素的累加，可以写成下面这个样子：

reduce(lambda x, y: x + y, [1,2,3])

在 Clojure 中，我们可以写的更加简单：

(reduce + [1 2 3])

可惜的是，Guava 并没有实现折叠操作。早在 2009 年的时候就有人在 Guava 的 issue¹ 中提出，为可迭代的集合增加一个 fold 方法，issue 讨论中大家也是贴出了各自的实现。然而，最后在 15 年 4 月 11 日这个 issue 被关闭了，Guava 的维护者决定不再向 Guava 添加函数式编程的特性，因为 Java 8 出来了。

虽然 Guava 的很多特性都在 Java 8 中得到了实现，但是并不是所有的开发者都能用上 Java 8。对于我们这些不得不使用 Java 7 甚至 Java 6 的开发者来说，Guava 就是帮助我们提升开发效率的神器。

源码分析

Collections2.transform

使用代理模式来实现延迟求值是 Guava 的惯用技法，transform 函数也不例外。

public static <F, T> Collection<T> transform(Collection<F> fromCollection,
    Function<? super F, T> function) {
  return new TransformedCollection<F, T>(fromCollection, function);
}

TransformedCollection 就是代理类，把传入的被操作集合和操作函数代理了起来，直到必要的时候才调用操作函数获取结果元素。

static class TransformedCollection<F, T> extends AbstractCollection<T> {
  final Collection<F> fromCollection;
  final Function<? super F, ? extends T> function;
  TransformedCollection(Collection<F> fromCollection,
      Function<? super F, ? extends T> function) {
    this.fromCollection = checkNotNull(fromCollection);
    this.function = checkNotNull(function);
  }
  @Override public void clear() {
    fromCollection.clear();
  }
  @Override public boolean isEmpty() {
    return fromCollection.isEmpty();
  }
  @Override public Iterator<T> iterator() {
    return Iterators.transform(fromCollection.iterator(), function);
  }
  @Override public int size() {
    return fromCollection.size();
  }
}

因为 Collection 的元素只能通过迭代器去遍历访问，所有我们只需要跟着 iterator 方法走下去，就能搞清楚 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);
    }
  };
}

Iterators.transform 函数返回了一个闭包，继承自抽象类 TransformedIterator。闭包中定义了操作函数的调用时机，那么我们接下来要找的就是 TransformedIterator#transform 的调用者了。

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();
  }
}