Question

我有一个构造几个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();
}

有没有办法将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(),
                     ...);

对我来说似乎不那么令人费解。

Java 8并行流或方法执行

1 个答案: