如何在Java8中将流减少到另一个流?

时间:2015-06-06 10:35:58

标签: java java-8 java-stream

作为一个例子,我想创建一个包含数十个像这样的群组的无限流:

0=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
1=[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
2=[20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
...

我想使用inifinte的int作为输入流,然后将其分组。如果第一个流迭代10次,则结果流应该只迭代一次。

我的工作但非常优雅的代码如下所示:

// create a stream from 0 (inclusive) to 100 (exclusive)
IntStream.iterate(0, i -> i+1).boxed().limit(100)

// slow down
.peek((i) -> {try {Thread.sleep(50);} catch (InterruptedException e) {}})

// group by tens
/* ugly: */.collect(Collectors.groupingBy(i -> i / 10)).entrySet()
/* not working: */ //.makeSequentialGroups(i -> i / 10)

// print to console
.forEach(System.out::println);  

如何创建int流组,而不必收集和重新流? (如果可能,甚至不必使用拳击)

4 个答案:

答案 0 :(得分:2)

我怀疑是否有办法,因为你不能在没有收集的情况下从sequence to a Map in java 8进行映射,也不能在没有收集的情况下进行分组。你可以创建自己的流,但我怀疑你真的想走那条路。

所以,虽然这不是一个答案,如果你想节省一些时钟周期,我会选择这样的东西:

IntStream.range(0, 10)
          .boxed()
          .collect(Collectors.toMap(
              Function.identity(), 
              (x) -> IntStream.range(x * 10, x * 10 + 10)
          )) 

答案 1 :(得分:1)

似乎一个流基于另一个流,而不是总是必须具有完全相同的条目数。

然而,我找到了解决问题的方法:我将消费者包装成了一个" GroupingConsumer"。这将终止初始流,但仍然可以无限期执行。

结果代码剪断:

// create a stream from 0 (inclusive) to infinity!
IntStream.iterate(0, i -> i+1).boxed()

// slow down
.peek((i) -> {try {Thread.sleep(50);} catch (InterruptedException e) {}})

// terminate the stream of single items (ungrouped)
.forEach(

    // create a wrap-around
    GroupingConsumer.create(

        // define the grouping rule
        i -> i/10,

        // the wrapped consumer
        System.out::println
)); 

GroupingConsumer类:

import java.util.AbstractMap.SimpleEntry;
import java.util.ArrayList;
import java.util.List;
import java.util.Map.Entry;
import java.util.function.Consumer;
import java.util.function.Function;

/**
 * Forwards a group of items, whenever the grouping-key changes
 *
 * @param <K> the type of the grouping key
 * @param <T> the type of the single entries
 */
class GroupingConsumer<K, T> implements Consumer<K> {

    private Function<K, T> keyCalculator;
    private Consumer<Entry<T, List<K>>> consumer;

    Entry<T, List<K>> currentGroup;

    /**
     * Wraps your consumer, so that it will get groups of items instead of single items.
     * 
     * @param keyCalculator the "grouping by"
     * @param consumer your consumer, that will be called less frequently
     * @return the wrapped consumer
     */
    public static <K, T> GroupingConsumer<K,T> create(Function<K, T> keyCalculator, Consumer<Entry<T, List<K>>> consumer) {
        GroupingConsumer<K, T> groupingConsumer = new GroupingConsumer<K, T>();
        groupingConsumer.consumer = consumer;
        groupingConsumer.keyCalculator = keyCalculator;
        return groupingConsumer;
    }

    @Override
    public void accept(K nextValue) {
        T key = keyCalculator.apply(nextValue);

        boolean newGroupRequired = false;

        if (currentGroup == null)
            newGroupRequired = true;
        else if (!currentGroup.getKey().equals(key)) {
            newGroupRequired = true;
            consumer.accept(currentGroup);
        }

        if (newGroupRequired)
            currentGroup = new SimpleEntry<T, List<K>>(key, new ArrayList<K>());
        currentGroup.getValue().add(nextValue);
    }
}

答案 2 :(得分:1)

这个功能在我的StreamEx库中可用并被称为groupRuns:您可以根据提供的谓词将相邻元素收集到中间列表中。例如:

<!DOCTYPE html>
<html>

<head>
  <title>DIV</title>
</head>

<body>

  <div>asjdkljaddddsadsssssssdfsdfsdfsf</div>

</body>

</html>

答案 3 :(得分:0)

您可以将数组视为具有基本类型int的键类型的地图,唯一的区别是不是通过map.get(i)查找值,而是通过{{1}查找值}}。使用数组对数组进行分组可以让您避免装箱,如您所要求的那样。这是一种无拳击产生类似结果的解决方案。

myArray[i]