Question

我想加倍Stream（没有DoubleStream）。意思是我从流开始并想要获得一个新流，其中旧流的每个元素都流式传输两次。所以1,2,3,4,4,5给了我们1,1,2,2,3,3,4,4,4,4,5,5。有没有这样的流操作？

Answer 1

创建一个内部流，它将包含两次当前元素并且flatMap此流。

stream.flatMap(e -> Stream.of(e,e))

如果要将元素数乘以n，可以创建一个像这样的实用方法：

public static <T> Stream<T> multiplyElements(Stream<T> in, int n) {
    return in.flatMap(e -> IntStream.range(0, n).mapToObj(i -> e));
    //  we can also use    IntStream.rangeClosed(1, n) 
    //  but I am used to iterating from 0 to n (where n is excluded)
}

（但尝试为此方法使用更好的名称，因为当前的方法可能不明确）

用法示例：

multiplyElements(Stream.of(1,2), 3).forEach(System.out::println);

输出：

Answer 2

您可以为每个原始元素创建一个包含2个元素的流，并对其进行flatMap：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 4, 5);
List<Integer> doubled = list.stream().flatMap(i -> Stream.of(i, i)).collect(toList());

Answer 3

以下是biziclop在评论中描述的一个简单示例。

static <E> Collection<E> multiply(Collection<E> source, int count) {
    return new AbstractCollection<E>() {
        @Override
        public int size() {
            return count * source.size();
        }
        @Override
        public Iterator<E> iterator() {
            return new Iterator<E>() {
                final Iterator<E> it = source.iterator();

                E next;
                int i = 0;

                @Override
                public boolean hasNext() {
                    return i < size();
                }
                @Override
                public E next() {
                    if (hasNext()) {
                        if ((i % count) == 0) {
                            next = it.next();
                        }
                        ++i;
                        return next;
                    } else {
                        throw new NoSuchElementException();
                    }
                }
            };
        }
    };
}

（Ideone上的工作示例。）

CW，因为这不是我的想法，flatMap建议更直接地回答了问题。

加倍流

3 个答案: