[英]Java stream reduce
I have the following example data set that I want to transform / reduce using Java stream api based on direction's value 我有以下示例数据集,我想根据方向的值使用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
to 至
Direction int[]
IN 1, 2,
OUT 3, 4, 5, 6, 7
IN 8, 9, 10, 11
OUT 12, 13
IN 14
code that I've written so far 到目前为止我写的代码
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. 我相信有一个更好,更简单的替代方案来实现同样的目标。
Online examples and blogs I've found for Java stream api reduce/combine use Integer::sum function only. 我发现的Java流api reduce / combine的在线示例和博客仅使用Integer :: sum函数。 Hoping to build this up for more complex case scenarios. 希望为更复杂的案例场景构建它。
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. 但Holger指出,使用collect
而不是reduce
更容易。 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;
}
Instead of using indexes to access the first/last element you could even use LinkedList
and the methods add/removeFirst/Last()
. 您可以使用LinkedList
和方法add/removeFirst/Last()
而不是使用索引来访问第一个/最后一个元素。
How about this. 这个怎么样。 First define a small helper method: 首先定义一个小帮助方法:
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);
}
This is close to your concat/merge
I guess, but a single one. 这是接近你的concat/merge
我想,但只有一个。 Basically a way to merge two Tuple
(s) together. 基本上是一种将两个Tuple
组合并在一起的方法。
And a helper method to produce the needed Collector
, you can put this into a utility so that it can be re-used: 并且有一个生成所需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);
}
And usage would be, for example: 例如,使用方法是:
List<Tuple> merged = tuples.stream()
.parallel()
.collect(mergedTuplesCollector());
This is an alternative approach that uses slightly different data structures. 这是一种使用略有不同的数据结构的替代方法。
If this is an option, changing from int[]
to List<Integer>
allows for more flexibility (not to mention avoiding creating/copying arrays multiple times): 如果这是一个选项,则从int[]
更改为List<Integer>
可以提供更大的灵活性(更不用说避免多次创建/复制数组):
class Tuple {
Direction direction;
List<Integer> data;
}
And the following function does the merging on a Deque
collection: 以下函数对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;
}
}
And with that, the stream can look as simple as: 有了它,流可以看起来像这样简单:
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()));
I've got two ideas on this topic. 我对这个话题有两个想法。 First one is getting the indices like in this answer and group it accordingly. 第一个是得到这个答案中的索引并相应地对其进行分组。
The second idea - if you already got a Stream
a custom Collector
should be used (similar to the other solutions, though using Deque
): 第二个想法 - 如果你已经有一个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);
}
};
}
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.