Java 8并行流或方法执行

我有一个类，它构造了几个foo对象。现在的问题是，该类沿着列表逐一迭代并构建它们。我想看看是否有办法让所有的建筑同时进行。这是一节有问题的课：

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();
}

---

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

但实际上，您可以使用流：

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

也就是说，我真的不知道在类上进行迭代以找到在每个类上调用哪个方法会得到什么。为什么不直接使用

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

---

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

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

但实际上，您可以使用流：

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

也就是说，我真的不知道在类上进行迭代以找到在每个类上调用哪个方法会得到什么。为什么不直接使用

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

---

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

你的

过滤器不正确：
map
首先，然后过滤
isPresent
。你的
过滤器不正确：
map
首先，然后过滤
isPresent
。我尝试此操作时出错。它在方法引用中说
返回类型不正确：无法将Optional转换为R
您的类列表应该是
list类型。我尝试将列表从
list
更改为
list。它在这里编译得很好，有一个完整的最小自包含示例：。不知道为什么它不在你身边。尝试发布一个完整的最小自包含示例，再现编译错误。若要将另一个参数传递给findByType，请使用lambda而不是方法引用：
map（clazz->findByType（clazz，1，2，3））
我尝试此操作时出错。它在方法引用中说
返回类型不正确：无法将Optional转换为R
您的类列表应该是
list类型。我尝试将列表从
list
更改为
list。它在这里编译得很好，有一个完整的最小自包含示例：。不知道为什么它不在你身边。尝试发布一个完整的最小自包含示例，再现编译错误。若要将另一个参数传递给findByType，请使用lambda而不是方法引用：
map（clazz->findByType（clazz，1，2，3））