1

我最近开始在 Scala 中工作，那是我第一次真正接触到函数式范例。尽管我是 Java 的忠实粉丝，而且我承认，它有时缺乏函数式范式。

这就是为什么我最近开始了一个迷你宠物项目，看看在某种程度上，这样的事情是否可以在 Java 中实现。

我从一个简单的数组列表修改开始，这就是我目前所拥有的：

任何集合都需要实现的接口，以便为其元素提供应用功能：

public interface Functionalizable<E> {
    public Collection<E> apply(Function<E> f);
}

定义在单个元素上应用函数的方法的接口：

public interface Function<E> {
    public E apply(E e);
}

一个由数组列表支持的具体类，允许在其元素上应用函数：

public class FunctionArrayList<E> implements List<E>, Functionalizable<E> {
    private List<E> list;

    //implemented methods from `List` interface and ctors

    @Override
    public List<E> apply(Function<E> f) {

        List<E> applied = new FunctionArrayList<>(this.list.size());

        for (E e : this.list) {
            applied.add(f.apply(e));
        }

        return applied;
    }
}

我已经为 Integer 编写了一个小的测试方法，它工作正常：

代码：

    List<Integer> listOfIntegersBefore = new FunctionArrayList<>();
    listOfIntegersBefore.add(-1);
    listOfIntegersBefore.add(0);
    listOfIntegersBefore.add(1);
    listOfIntegersBefore.add(2);
    listOfIntegersBefore.add(3);
    listOfIntegersBefore.add(4);

    System.out.println("Before<Integer>: " + listOfIntegersBefore.toString());

    List<Integer> listOfIntegersAfter = ((FunctionArrayList<Integer>) listOfIntegersBefore).apply(new Function<Integer>() {

        @Override
        public Integer apply(Integer e) {
            return (e + 1);
        }
    });

    System.out.println("After<Integer> : " + listOfIntegersAfter.toString());

输出：

Before<Integer>: [-1, 0, 1, 2, 3, 4]
After<Integer> : [0, 1, 2, 3, 4, 5]

然而，当我尝试用 List 做一些更复杂的事情时，我最终会遇到很多我不喜欢的类型转换（我想尽可能避免它）。
代码：

    List<List<Integer>> listOfListOfIntegersBefore = new FunctionArrayList<>();

    List<Integer> temp = new FunctionArrayList<>();
    temp.add(1);
    listOfListOfIntegersBefore.add(temp);

    temp = new FunctionArrayList<>();
    temp.add(1);
    temp.add(2);
    listOfListOfIntegersBefore.add(temp);

    temp = new FunctionArrayList<>();
    temp.add(1);
    temp.add(2);
    temp.add(3);
    listOfListOfIntegersBefore.add(temp);

    temp = new FunctionArrayList<>();
    temp.add(1);
    temp.add(2);
    temp.add(3);
    temp.add(4);
    listOfListOfIntegersBefore.add(temp);

    List<List<Integer>> listOfListOfIntegersAfter = (List<List<Integer>>) ((Functionalizable<List<Integer>>) listOfListOfIntegersBefore).apply(new Function<List<Integer>>() {

        @Override
        public List<Integer> apply(List<Integer> e) {
            List<Integer> list = new FunctionArrayList<>(e);

            return ((FunctionArrayList<Integer>) list).apply(new Function<Integer>() {

                @Override
                public Integer apply(Integer e) {
                    return (e + 1);
                }
            });
        }
    });
    System.out.println("Before<List<Integer>>: " + listOfListOfIntegersBefore);
    System.out.println("After<List<Integer>> : " + listOfListOfIntegersAfter);

输出：

Before<List<Integer>>: [[1], [1, 2], [1, 2, 3], [1, 2, 3, 4]]
After<List<Integer>> : [[2], [2, 3], [2, 3, 4], [2, 3, 4, 5]]

正如我已经提到的，我想避免强制转换。Type safety: Unchecked cast from List<List<Integer>> to Functionalizable<List<Integer>>另外，Eclipse在这一行警告我：

List<List<Integer>> listOfListOfIntegersAfter = (List<List<Integer>>) ((Functionalizable<List<Integer>>) listOfListOfIntegersBefore).apply(new Function<List<Integer>>() {
    ...
}

有没有一种优雅的方式来实现这一点？

4

2 回答 2

2

你让自己的生活变得艰难。

List<List<Integer>> listOfListOfIntegersBefore = new FunctionArrayList<>();
[...]
((FunctionArrayList<Integer>) listOfIntegersBefore).apply

为什么不首先将其存储为 aFunctionArrayList呢？当然，您必须以这种方式进行投射。

无论如何，我发现将每个列表包装在一个功能列表中有点烦人，我宁愿用简单的静态方法来做：

public interface F<S, T> { T apply(S s); }


public final class FunctionalStuff {
  private FunctionalStuff() {}


  public <S, T> static List<T> map(Collection<? extends S> collection,
                                   F<? super S, ? extends T> func) {
    final List<T> result = new ArrayList<T>(collection.size()); 
    for (S source : collection)
      result.add(func.apply(source)); 
    return result;
  }


  public <S, T> static List<S> filter(Collection<? extends S> collection,
                                      F<? super S, Boolean> predicate) {
    final List<T> result = new ArrayList<T>(collection.size()); 
    for (S source : collection)
      if (predicate.apply(source))
        result.add(source); 
    return result; 
  }

  // etc etc.
}

无论如何，请注意：我不建议您在 Java 中进行函数式编码。等待将在 Java 8 中添加的闭包。

或者使用包含函数式风格的语言：Scala、Javascript、Clojure、Lisp、Mathematica 等，有很多！甚至 c(++) 在这方面似乎也比 Java 不那么烦人。

于 2012-07-14T14:03:57.890 回答
0

也许您想查看op4j。我认为他们以一种非常简洁的方式完成了您想要实现的目标。要么查看资源并从中学习，要么直接使用库。

于 2012-07-14T14:20:54.207 回答