从并行流中收集部分结果

Question

在Java8中，处理两个并行流中的项目对，如下所示：

final List<Item> items = getItemList();
final int l = items.size();
List<String> results = Collections.synchronizedList(new ArrayList<String>());
IntStream.range(0, l - 1).parallel().forEach(
    i -> {
        Item item1 = items.get(i);
        int x1 = item1.x;
        IntStream.range(i + 1, l).parallel()
            .forEach(j -> {
                Item item2 = items.get(j);
                int x2 = item2.x;
                if (x1 + x2 < 200) return;
                // code that writes to ConcurrentHashMap defined near results
                if (x1 + x2 > 500) results.add(i + " " + j);
            });
    }
);

每个流对都写入ConcurrentHashMap，并且根据某些条件，它可能会通过调用return; 来终止流执行，或者它可能会写入同步列表。

我想让流返回像return i + " " + j 这样的结果，并将这些结果收集到外面的列表字符串中。它应该是部分的，因为必须支持不返回任何内容（以防x1 + x2 < 200）。

实现这一目标的最省时（最快的代码）方法是什么？

Answer 1

在这个答案中，我不会讨论时间效率，因为有正确性问题需要事先处理。

正如我在 cmets 中所说，如果我们并行化流，则不可能在特定条件后停止流执行。否则，可能有一些对 (i,j) 已经在执行，它们在数字上位于触发停止条件 x1 + x2 < 200 的对之后。 另一个问题是 lambda 中的 return;，它所要做的就是跳过第二个 if 以获取 x1 + x2 < 200 所在的 j，但流将继续使用 j+1。

在 Java 中没有直接的方法来停止流，但我们可以使用 allMatch 来实现，因为我们可以预期，一旦它找到 false 值，它将短路并返回 @987654330 @正确的方式。

所以，这将是您的代码的正确版本：

IntStream.range(0, l - 1).allMatch(i -> {
    int x1 = items.get(i).x;
    return IntStream.range(i + 1, l).allMatch(j -> {
        int x2 = items.get(j).x;
        if (x1 + x2 < 200) {
            return false;
        } else {
            if (x1 + x2 > 500) results2.add(i + " " + j);
            return true;
        }
    });
});

对于以下示例，使用构造函数Item(int x, int y)：

final List<Item> items = Arrays.asList(
        new Item(200, 0),
        new Item(100, 0),
        new Item(500, 0),
        new Item(400, 0),
        new Item(1, 0));

我的版本中results的内容是：

[0 2, 0 3, 1 2]

使用您的代码（每次执行的顺序和元素都不同）：

[2 4, 2 3, 1 2, 0 3, 0 2]

Answer 2

我认为这会更有效（虽然没有进行任何微基准测试）：

IntStream.range(0,l-1).forEach(
    i -> IntStream.range(i+1,l)
                  .filter(j -> items.get(i).x + items.get(j).x > 500)
                  .forEach(j -> results.add(i + " " + j)));

但是，如果我真的担心执行此操作所花费的时间，我会更加注意items 使用了什么样的List 实现。在进入 lambda 之前，甚至可以将列表转换为 HashMap<Integer, Item>。例如，如果 items 是 LinkedList，则对 lambda 的任何改进都可能无关紧要，因为 items.get() 会一直吃光。