如何将Java枚举转换为流？

我有一个第三方图书馆给我一个图书馆Enumeration<String>。我想像Java 8那样懒惰地使用该枚举，并Stream调用诸如此类的东西。filtermapflatMap

有没有现成的图书馆？我已经在引用Guava和Apache Commons，所以如果它们中的任何一个都有理想的解决方案。

另外，在保留所有内容的懒惰性质的同时将Enumerationa变成最佳/最简单的方法Stream是什么？

这个答案已经提供了一个解决方案，可以解决Stream以下问题Enumeration：

 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。

为什么不使用香草Java：

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

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

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

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

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

如果您使用的不是Java 9，则可以使用Holger answer中给出的技术Enumeration将Iterator手动转换为Java 。

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

Enumeration<Something> enumeration = ...;

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

在这个问题中，将说明如何从迭代器获取流：

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

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

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

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