Java 8 并行流或方法执行

Question

我有一个构造多个 foo 对象的类。现在的问题是该类在列表中逐一迭代并构建它们。我想看看是否有办法让所有的建筑并行进行。这是有问题的类(class):

public List<Foo> create() {}
    List<Class> fooTypes = Arrays.asList(
                    Foo1.class,
                    Foo2.class,
                    Foo3.class,
                    Foo4.class,
                    Foo5.class,
                    Foo6.class
            );

    List<Foo> foos = new ArrayList<>();

    for(Class<? extends Foo> fooType : fooTypes) {
        Optional<Foo> foo = findByType(fooType);
        if(foo.isPresent()) {
            foos.add(foo.get());
        }
    }
    return foos;
}

private Optional<Foo> findByType(Class<? extends Foo> fooClass) {
    if(fooClass.isAssignableFrom(Foo1.class)) {
        return Optional.ofNullable(foo1());
    }
    if(fooClass.isAssignableFrom(Foo2.class)) {
        return Optional.ofNullable(foo2());
    }
    if(fooClass.isAssignableFrom(Foo3.class)) {
        return Optional.ofNullable(foo3());
    }
    if(fooClass.isAssignableFrom(Foo4.class)) {
        return Optional.ofNullable(foo4());
    }
    if(fooClass.isAssignableFrom(Foo5.class)) {
        return Optional.ofNullable(foo5());
    }
    if(fooClass.isAssignableFrom(Foo6.class)) {
        return Optional.ofNullable(foo6());
    }
    return Optional.empty();
}

private Alert foo1() {
    return new Foo1Builder().build();
}
private Alert foo2() {
    return new Foo2Builder().build();
}
private Alert foo3() {
    return new Foo3Builder().build();
}
private Alert foo4() {
    return new Foo4Builder().build();
}
private Alert foo5() {
    return new Foo5Builder().build();
}
private Alert foo6() {
    return new Foo6Builder().build();
}

有没有办法将 foreach 循环转换为 java 8 并行流？如果没有，是否会执行概述的执行程序路线 here正确的走法？我尝试过类似的方法来实现并行流，但有些地方不正确:

foos = fooTypes
        .parallelStream()
        .filter(a -> findByType(a).isPresent())
        .map(Optional::get)
        .collect(Collectors.toList());

Answer 1

对于如此少量的元素，并行流的效率将远低于顺序流。这太过分了。

但您确实可以使用 Stream:

foos = fooTypes
        .stream()
        .map(this::findByType)
        .filter(Optional::isPresent)
        .map(Optional::get)
        .collect(Collectors.toList());

就是说，我真的不知道通过迭代这些类来找到在每个类上调用哪个方法会得到什么。为什么不直接使用

return Arrays.asList(new Foo1Builder().build(),
                     new Foo2Builder().build(),
                     ...);

这对我来说似乎没那么复杂。