Java поток уменьшить

Question

У меня есть следующий пример набора данных, который я хочу преобразовать / уменьшить, используя Java-поток API, основываясь на значении направления

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

до

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

Я считаю, что есть лучшая и более простая альтернатива достижению того же самого.

Онлайн-примеры и блоги, которые я нашел для потока Java, API-интерфейсы сокращения / комбинирования используют только функцию Integer :: sum. Надеемся построить это для более сложных сценариев.

Answer 1

У меня есть две идеи на эту тему. Сначала получают индексы как в этом ответе и группируют его соответственно.

Вторая идея - если у вас уже есть Stream, следует использовать пользовательский Collector (аналогично другим решениям, хотя и с использованием Deque):

private Collector<Tuple, ?, List<Tuple>> squashTuples() {
  return new Collector<Tuple, Deque<Tuple>, List<Tuple>>() {
    @Override
    public Supplier<Deque<Tuple>> supplier() {
      return ArrayDeque::new;
    }

    @Override
    public BiConsumer<Deque<Tuple>, Tuple> accumulator() {
      return (acc, e) -> {
        Objects.requireNonNull(e);
        if (!acc.isEmpty() && acc.peekLast().getDirection() == e.getDirection()) {
          acc.offerLast(acc.pollLast().merge(e));
        } else {
          acc.offerLast(e);
        }
      };
    }

    @Override
    public BinaryOperator<Deque<Tuple>> combiner() {
      return (left, right) -> {
        if (!left.isEmpty() && !right.isEmpty() && left.peekLast().getDirection() == right.peekFirst().getDirection()) {
          left.offerLast(left.pollLast().merge(right.pollFirst()));
        }
        left.addAll(right);
        return left;
      };
    }

    @Override
    public Function<Deque<Tuple>, List<Tuple>> finisher() {
      return ArrayList::new;
    }

    @Override
    public Set<Characteristics> characteristics() {
      return EnumSet.noneOf(Characteristics.class);
    }
  };
}

Answer 2

Это альтернативный подход, который использует слегка отличающиеся структуры данных.

Если это опция, изменение с int[] на List<Integer> обеспечивает большую гибкость (не говоря уже об избежании создания / копирования массивов несколько раз):

class Tuple {
    Direction direction;
    List<Integer> data;
}

И следующая функция выполняет слияние в коллекции Deque:

private static List<Integer> next(Deque<Tuple> t, Direction d) {
    if (!t.isEmpty() && t.peekLast().getDirection() == d) {
        return t.peekLast().getData();
    } else {
        Tuple next = new Tuple();
        next.direction = d;
        next.data = new ArrayList<>();
        t.addLast(next);
        return next.data;
    }
}

И при этом поток может выглядеть так просто:

Deque<Tuple> deq = new LinkedList<>(); //the final collection of tuples

tuples.stream()
.flatMap(tp -> tp.getData().stream()
                 .map(d -> Pair.of(tp.getDirection(), Integer.valueOf(d))))
.forEach(el -> next(deq, el.getLeft()).add(el.getRight()));

Answer 3

Как насчет этого. Сначала определите маленький вспомогательный метод:

private static Tuple mergeTwo(Tuple left, Tuple right) {
    int[] leftArray = left.getData();
    int[] rightArray = right.getData();
    int[] result = new int[leftArray.length + rightArray.length];
    System.arraycopy(leftArray, 0, result, 0, leftArray.length);
    System.arraycopy(rightArray, 0, result, leftArray.length, rightArray.length);
    return new Tuple(left.getDirection(), result);
}

Это близко к вашему concat/merge Полагаю, но один. В основном способ объединить два Tuple (s) вместе.

И вспомогательный метод для получения необходимого Collector, вы можете поместить его в утилиту, чтобы его можно было повторно использовать:

private static Collector<Tuple, ?, List<Tuple>> mergedTuplesCollector() {
    class Acc {

        ArrayDeque<Tuple> deque = new ArrayDeque<>();

        void add(Tuple elem) {
            Tuple head = deque.peek();
            if (head == null || head.getDirection() != elem.getDirection()) {
                deque.offerFirst(elem);
            } else {
                deque.offerFirst(mergeTwo(deque.poll(), elem));
            }
        }

        Acc merge(Acc right) {

            Tuple lastLeft = deque.peekLast();
            Tuple firstRight = right.deque.peekFirst();

            if (lastLeft.getDirection() == firstRight.getDirection()) {
                deque.offerLast(mergeTwo(deque.pollLast(), right.deque.pollFirst()));
            } else {
                deque.addAll(right.deque);
            }

            return this;
        }

        public List<Tuple> finisher() {
            return new ArrayList<>(deque);
        }

    }
    return Collector.of(Acc::new, Acc::add, Acc::merge, Acc::finisher);
}

И использование будет, например:

List<Tuple> merged = tuples.stream()
            .parallel()
            .collect(mergedTuplesCollector());

Answer 4

Я думаю, что ваше решение уже довольно неплохо, тем более что использование сокращения позволяет легко распараллелить его по сравнению со сбором в общий внешний контейнер. Но проще использовать collect вместо reduce, как указал Хольгер. Кроме того, условия в аккумуляторе можно немного упростить, и вы забыли объединить последние и первые элементы в сумматоре:

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().