Java流减少 [英] Java stream reduce

问题描述

我有以下示例数据集，我想根据方向的值使用Java流api进行转换/缩减

I have the following example data set that I want to transform / reduce using Java stream api based on direction's value

Direction    int[]
IN           1, 2
OUT          3, 4
OUT          5, 6, 7
IN           8
IN           9
IN           10, 11
OUT          12, 13
IN           14

to

Direction    int[]
IN           1, 2, 
OUT          3, 4, 5, 6, 7
IN           8, 9, 10, 11
OUT          12, 13
IN           14

代码我到目前为止写的

enum Direction { IN, OUT }

class Tuple {
  Direction direction;
  int[] data;

  public Tuple merge(Tuple t) {
      return new Tuple(direction, concat(getData(), t.getData()));
  }
}

private static int[] concat(int[] first, int[] second) {
    int[] result = Arrays.copyOf(first, first.length + second.length);
    System.arraycopy(second, 0, result, first.length, second.length);
    return result;
}

List<Tuple> reduce = tupleStream.reduce(new ArrayList<>(), WDParser::add, WDParser::combine);

private static List<Tuple> combine(List<Tuple> list1, List<Tuple> list2) {
    System.out.println("combine");
    list1.addAll(list2);
    return list1;
}

private static List<Tuple> add(List<Tuple> list, Tuple t) {
    System.out.println("add");
    if (list.size() == 0) {
        list.add(t);
    } else if (list.size() > 0) {
        int lastIndex = list.size() - 1;
        Tuple last = list.get(lastIndex);
        if (last.getDirection() == t.getDirection())
            list.set(lastIndex, last.merge(t));
        else
            list.add(t);
    }

    return list;
}

我相信有更好，更简单的替代方法。

I believe there is a better and simpler alternative to achieving the same.

我发现Java流api reduce / combine的在线示例和博客仅使用Integer :: sum函数。希望为更复杂的案例场景构建它。

Online examples and blogs I've found for Java stream api reduce/combine use Integer::sum function only. Hoping to build this up for more complex case scenarios.

推荐答案

我认为你的解决方案已经非常好了，特别是在使用减少时与收集到共享的外部容器相比，可以轻松实现并行性。但Holger指出，使用收取而不是 reduce 更容易。此外，累加器中的条件可以简化一点，您忘记合并组合器中的最后一个元素和第一个元素：

I think your solution is pretty nice already, especially as using a reduction enables parallelism easily compared to collecting into a shared outside container. But it's easier to use collect instead of reduce as Holger pointed out. Furthermore, the conditions in the accumulator can be simplified a bit, and you forgot to merge the last and first elements in the combiner:

List<Tuple> reduce = tupleStream.collect(ArrayList::new, WDParser::add, WDParser::combine);

private static List<Tuple> combine(List<Tuple> list1, List<Tuple> list2)
{
    if (!list2.isEmpty())
    {
        add(list1, list2.remove(0)); // merge lists in the middle if necessary
        list1.addAll(list2);         // add all the rest
    }
    return list1;
}

private static List<Tuple> add(List<Tuple> list, Tuple t)
{
    int lastIndex = list.size() - 1;
    if (list.isEmpty() || list.get(lastIndex).getDirection() != t.getDirection())
    {
        list.add(t);
    }
    else
    {
        list.set(lastIndex, list.get(lastIndex).merge(t));
    }
    return list;
}

除了使用索引访问第一个/最后一个元素，你甚至可以使用 LinkedList 和方法 add / removeFirst / Last（）。

Instead of using indexes to access the first/last element you could even use LinkedList and the methods add/removeFirst/Last().

这篇关于Java流减少的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！