如何将 Java 枚举转换为流？

Question

我有一个第三方库，它给了我Enumeration<String>。我想以 Java 8 Stream 的形式懒惰地使用该枚举，在其上调用 filter、map 和 flatMap 之类的东西。

是否有一个现有的图书馆包含这个？我已经在参考 Guava 和 Apache Commons，所以如果其中任何一个都有理想的解决方案。

或者，将Enumeration 转换为Stream 的最佳/最简单方法是什么，同时保留一切的惰性？

Answer 1

为什么不使用原生 Java：

Collections.list(enumeration).stream()...

但是正如@MicahZoltu 提到的，必须考虑枚举中的项目数，因为Collections.list 将首先遍历枚举以复制ArrayList 中的元素。从那里可以使用常规的stream 方法。虽然这对于许多收集流操作来说很常见，但如果枚举太大（如无限），这可能会导致问题，因为必须将枚举转换为列表，然后应使用此处描述的其他方法。

Answer 2

This answer 已经提供了一个解决方案，可以从Enumeration 创建一个Stream：

 public static <T> Stream<T> enumerationAsStream(Enumeration<T> e) {
     return StreamSupport.stream(
         Spliterators.spliteratorUnknownSize(
             new Iterator<T>() {
                 public T next() {
                     return e.nextElement();
                 }
                 public boolean hasNext() {
                     return e.hasMoreElements();
                 }
             },
             Spliterator.ORDERED), false);
 }

应该强调的是，生成的Stream 是 与任何其他Stream 一样懒惰，因为它不会在终端操作开始之前处理任何项目，如果终端操作是短路的，它只会迭代尽可能多的项目。

不过，它还有改进的余地。当有一种直接的方式来处理所有元素时，我总是会添加一个forEachRemaining 方法。对于大多数非短路操作，Stream 实现将调用该方法：

public static <T> Stream<T> enumerationAsStream(Enumeration<T> e) {
    return StreamSupport.stream(
        Spliterators.spliteratorUnknownSize(
            new Iterator<T>() {
                public T next() {
                    return e.nextElement();
                }
                public boolean hasNext() {
                    return e.hasMoreElements();
                }
                public void forEachRemaining(Consumer<? super T> action) {
                    while(e.hasMoreElements()) action.accept(e.nextElement());
                }
            },
            Spliterator.ORDERED), false);
}

但是，上面的代码是“使用Iterator，因为它太熟悉了”反模式的受害者。创建的Iterator 将被包装到新的Spliterator 接口的实现中，并且与直接实现Spliterator 相比没有任何优势：

public static <T> Stream<T> enumerationAsStream(Enumeration<T> e) {
    return StreamSupport.stream(
        new Spliterators.AbstractSpliterator<T>(Long.MAX_VALUE, Spliterator.ORDERED) {
            public boolean tryAdvance(Consumer<? super T> action) {
                if(e.hasMoreElements()) {
                    action.accept(e.nextElement());
                    return true;
                }
                return false;
            }
            public void forEachRemaining(Consumer<? super T> action) {
                while(e.hasMoreElements()) action.accept(e.nextElement());
            }
    }, false);
}

在源代码级别上，此实现与基于Iterator 一样简单，但消除了从Spliterator 到Iterator 的委托。它只要求读者了解新的 API。

Answer 3

在 Java 9 中，可以使用单行将 Enumeration 转换为 Stream：

Enumeration<String> en = ... ;
Stream<String> str = StreamSupport.stream(
    Spliterators.spliteratorUnknownSize(en.asIterator(), Spliterator.ORDERED),
    false
);

（嗯，这是一条相当长的线。）

如果您不在 Java 9 上，您可以使用 Holger's answer 中提供的技术手动将 Enumeration 转换为 Iterator。

Answer 4

根据Guava docs，你可以使用Iterators.forEnumeration()方法：

Enumeration<Something> enumeration = ...;

Iterator<SomeThing> iterator = Iterators.forEnumeration(enumeration);

在this question 中，解释了如何从迭代器中获取流：

Stream<Something> stream = StreamSupport.stream(
    Spliterators.spliteratorUnknownSize(
        iterator, Spliterator.ORDERED),
    false);

Answer 5

在我的 StreamEx 库中，有一个简单的方法 StreamEx.of(Enumeration) 可以完成这项工作：

Stream<String> stream = StreamEx.of(enumeration);

请注意，它不仅是@Holger 解决方案的捷径，而且以不同的方式实现。特别是，与涉及Spliterators.spliteratorUnknownSize() 的解决方案相比，它具有明显更好的并行执行特性。