Java 使用函子连接集合

Question

给定 2 个具有相同数量元素的集合，例如 List。在 JAVA 中，有哪些优雅的方法可以在具有相应索引的集合的每 2 个元素上应用函子？

比如说，一个例子可以是：
列表<字符串> = { "苹果", "梨" };
列表<字符串> = { "BANANA", "ORANGE" };

将字符串连接在一起的谓词将产生以下 List：
列表<字符串> = { "APPLEBANANA", "梨橙" };

Answer 1

类似于 Apache Commons Collections 中找到的函子，我过去已经创建了二进制等价物。

对于您的情况，可以使用二进制转换器类型对象，它接受两个输入对象并返回一个对象。这是一些传达我的方法的示例代码：

// tranformer
interface BinaryTransformer<X, Y, Z> {
  Z transform(X a, Y b);
}

// implementation for your problem
class ConcatTransformer implements BinaryTransformer<String, String, String> {
  public String transform(String a, String b) {
    return a + b;
  }
}

// general use transformer
class BinaryListUtils {
  public static <X, Y, Z> List<Z> collect(List<X> aList, List<Y> bList, BinaryTransformer<X, Y, Z> t) {
    List<Z> ret = new ArrayList<Z>(aList.size());
    Iterator<X> aIter = aList.iterator();
    Iterator<Y> bIter = bList.iterator();
    while(aIter.hasNext()) {
      ret.add(t.transform(aIter.next(), bIter.next()));
    }
  }
}

HTH

Answer 2

一个快速驱动程序表明它可以工作。不对所有测试用例负责。 :-)

List<String> combineListsHorizontally(List<String> a, List<String> b) {
    assert a.size() == b.size(); // just avoids some checks

    List<String> result = new ArrayList<String>(a.size());

    Iterator<String> itera = a.iterator();
    Iterator<String> iterb = b.iterator();

    for(int i = 0; i < a.size(); i++) {
        String combined = itera.next() + iterb.next();
        result.add(combined);
    }
    return result;

}

如果你需要通用的东西，你需要知道它们有一种可以连接的方式

 List<E> combineListsHorizontally(List<E> a, List<E> b) {
        assert a.size() == b.size(); // just avoids some checks

        List<E> result = new ArrayList<E>(a.size());

        Iterator<E> itera = a.iterator();
        Iterator<E> iterb = b.iterator();

        for(int i = 0; i < a.size(); i++) {
            E combined = new MagicCombiner<E>(a,b).get(); // define this line yourself
            result.add(combined);
        }
        return result;

    }

/////////////////// 编辑 - 这是一个基于@Brents的工作示例（上级）示例。感谢他比我更好地阐释了这种模式。

import java.util.*;

/**
 * Compile: "javac BinaryListUtils"
 * Usage: "java BinaryListUtils"

 C:\Documents and Settings\user\My Documents>javac BinaryListUtils.java

 C:\Documents and Settings\user\My Documents>java BinaryListUtils
 APPLEBANANA
 PEARORANGE

 C:\Documents and Settings\user\My Documents>
 */

// general use transformer
class BinaryListUtils {

    // tranformer
    static interface BinaryTransformer<X, Y, Z> {
        Z transform(X a, Y b);
    }

    // implementation for your problem
    static class ConcatTransformer implements BinaryTransformer<String, String, String> {
        public String transform(String a, String b) {
            return a + b;
        }
    }

    public static <X, Y, Z> List<Z> collect(List<X> aList, List<Y> bList, BinaryTransformer<X, Y, Z> t) {
        List<Z> ret = new ArrayList<Z>(aList.size());
        Iterator<X> aIter = aList.iterator();
        Iterator<Y> bIter = bList.iterator();
        while(aIter.hasNext()) {
            ret.add(t.transform(aIter.next(), bIter.next()));
        }
        return ret;
    }

    public static void main(String[] args) {

        List<String> aList = new ArrayList<String>();
        List<String> bList = new ArrayList<String>();

        aList.add("APPLE");
        aList.add("PEAR");

        bList.add("BANANA");
        bList.add("ORANGE");

        ConcatTransformer ct = new ConcatTransformer();

        List<String> cList = BinaryListUtils.collect(aList,bList,ct);

        for(String s : cList) System.out.println(s);


    }
}

Answer 3

您要求的不是谓词。它正在对压缩在一起的列表进行转换。执行此操作的通用方法是编写一个可迭代拉链，它将两个列表压缩为可迭代的 Pair，然后将转换应用于这对。

我最初以为你是在要求两个集合的交集，它在 Guava 集合中作为 Sets.intersection(Set, Set) 提供。

Answer 4

我认为你最好的选择是迭代地进行。我想不出任何核心 Java API 可以做到这一点。

public List<String> predicate(List<String> list1, List<String> list2) {
    List<String> list = new ArrayList<String>();

    for(int i = 0; i < list1.size(); i++) {
        list.add(new StringBuilder(list1.get(i)).append(list2.get(i)).toString());
    }

    return list;
}

还没有编译/运行它。祝你好运。