【问题标题】:Using Java8 Streams to create a list of objects from another two lists使用 Java8 Streams 从另外两个列表创建对象列表
【发布时间】:2014-04-08 09:44:21
【问题描述】:

我有以下 Java6 和 Java8 代码:

List<ObjectType1> lst1 = // a list of ObjectType1 objects
List<ObjectType2> lst2 = // a list of ObjectType1 objects, same size of lst1

List<ObjectType3> lst3 = new ArrayLis<ObjectType3>(lst1.size());
for(int i=0; i < lst1.size(); i++){
  lst3.add(new ObjectType3(lst1.get(i).getAVal(), lst2.get(i).getAnotherVal()));
}

Java8 中有什么方法可以使用 Lambda 以更简洁的方式处理前面的 for 吗?

【问题讨论】:

  • 能否提供ObjectType3的实际构造函数?
  • 为什么在这里使用流?您现有的循环工作正常,流将较少可读
  • @fge 我知道。我想要一个单行解决方案。关于可读性,我认为这只是一个实践问题。我可以即时理解给定的解决方案。感谢您指出这一点!
  • 好的,但是“单行”和“更快”是不一样的......而且很容易做不可读的单行(我知道,我也做 perl):p
  • @fge 我知道,我的问题是寻找更简洁的方式,而不是更快!

标签: java lambda java-8 java-stream


【解决方案1】:

Stream 与给定的可迭代/集合绑定,因此您不能真正并行“迭代”两个集合。

一种解决方法是创建一个索引流,但它不一定会改进 for 循环。流版本可能如下所示:

List<ObjectType3> lst3 = IntStream.range(0, lst1.size())
         .mapToObj(i -> new ObjectType3(lst1.get(i).getAVal(), lst2.get(i).getAnotherVal()))
         .collect(toList());

【讨论】:

  • @mat_boy 它并没有比你以前的短。它确实很聪明,但我不认为这是一种改进。 Java8 不会弃用经典的 for 循环 :)
  • @JoeriHendrickx 当然,但我可以在一行中分配返回值。我知道,这并不重要,但我更喜欢这种方法。
  • @JoeriHendrickx 很明显,如果你写IntStream.range(0, lst1.size()).parallel(),那么你最终可能会加快你的执行时间!这是一个好点,不是吗? :)
  • 嗯,当然。但对我来说,这听起来像是过早的优化。您的代码的可读性应该始终是您最关心的问题。
【解决方案2】:

您可以创建一个将两个集合转换为新集合的方法,如下所示:

public <T, U, R> Collection<R> singleCollectionOf(final Collection<T> collectionA, final Collection<U> collectionB, final Supplier<Collection<R>> supplier, final BiFunction<T, U, R> mapper) {
    if (Objects.requireNonNull(collectionA).size() != Objects.requireNonNull(collectionB).size()) {
        throw new IllegalArgumentException();
    }
    Objects.requireNonNull(supplier);
    Objects.requireNonNull(mapper);
    Iterator<T> iteratorA = collectionA.iterator();
    Iterator<U> iteratorB = collectionB.iterator();
    Collection<R> returnCollection = supplier.get();
    while (iteratorA.hasNext() && iteratorB.hasNext()) {
        returnCollection.add(mapper.apply(iteratorA.next(), iteratorB.next()));
    }
    return returnCollection;
}

这里重要的部分是它将获取到的iteratorA.next()和iteratorB.next()映射到一个新的对象中。

它是这样称呼的:

List<Integer> list1 = IntStream.range(0, 10).boxed().collect(Collectors.toList());
List<Integer> list2 = IntStream.range(0, 10).map(n -> n * n + 1).boxed().collect(Collectors.toList());
singleCollectionOf(list1, list2, ArrayList::new, Pair::new).stream().forEach(System.out::println);

在你的例子中是:

List<ObjectType3> lst3 = singleCollectionOf(lst1, lst2, ArrayList::new, ObjectType3::new);

例如,Pair::new 是 lamdda (t, u) -&gt; new Pair(t, u) 的简写。

【讨论】:

    【解决方案3】:

    我还没有找到将一个流更新到另一个流的方法,但是,我使用 Map 完成了类似的壮举。 :)

        Map<Integer, String> result = new HashMap<>();
        for(int index = 100; index > 0; index--){
            result.put(index, String.valueOf(index));
        }
        result.keySet().stream()
                .filter(key -> key%3 == 0)
                .sorted()
                .forEach(key -> result.put(key, "Fizz"));
    
        result.keySet().stream()
                .filter(key -> key%5 == 0)
                .sorted()
                .forEach(key -> result.put(key, "Buzz"));
    
        result.keySet().stream()
                .filter(key -> key%3 == 0 && key%5 == 0)
                .sorted()
                .forEach(key -> result.put(key, "FizzBuzz"));
    
        result.keySet().stream().forEach(key -> System.out.println(result.get(key)));
    

    【讨论】:

    • 这个答案完全是我们的范围!
    • 似乎与问题描述相匹配:“使用 Java8 Streams 从另一个对象创建对象列表” 一个映射可以定义为 2 个对象列表,从域到范围具有 1 对 1 的映射。编程就是创造性的解决方案。
    • 在我的示例中,我使用 List 而不是 Map。这是两个不同的界面,正如我所说,我需要列表。
    猜你喜欢
    • 2023-03-14
    • 1970-01-01
    • 1970-01-01
    • 1970-01-01
    • 2020-05-15
    • 1970-01-01
    • 2019-10-26
    • 1970-01-01
    • 2020-04-08
    相关资源
    最近更新 更多