如何使用Java 8流遍历多个列表？

Question

我有三个列表，

List<Double> list1= new ArrayList(List.of(1, 1.5));
List<Double> list2= new ArrayList(List.of(30, 25));
List<Double> list3= new ArrayList(List.of(30, 25));

我想同时遍历每个元素，并打印输出。

1    30  30
1.5  25  25

我该如何使用Java 8的Stream API来完成这个任务？

- Neha

---

提醒一下，为什么“for comprehensions”很棒。 :) - Branislav Lazic

Answer 1

假设所有列表的大小相同，您可以这样做：

IntStream.range(0, list1.size())
         .forEach(x -> Syso(list1.get(x) + " " + list2.get(x) + " " + list3.get(x)))

这里实际上没有任何好处，只需使用普通的 for 循环即可。

另外，不要用 new ArrayList(List.of(30, 25)); 包装它们，这样就足够了：

 List<Double> list1 = List.of(1D, 1.5D)

- Eugene

Answer 2

List.of(..)是一个静态工厂，返回一个List本身，不需要将其包装在ArrayList::new构造函数中。

这里是您可能需要的代码，但不要低估for-loop的威力：

// Here you need to get the max of all the List sizes to traverse all Lists
int maxSize = Math.max(list1.size(), Math.max(list2.size(), list3.size()));      

IntStream.range(0, maxSize)                                    // Iterate 0 .. minSize-1
         .mapToObj(i -> Stream.of(list1, list2, list3)         // Map each index
                              .filter(list -> i < list.size()) // Secure the existing index
                              .map(list -> list.get(i))        // Get the item
                              .collect(Collectors.toList()))   // Collect to List
                              .forEach(System.out::println);   // And iterate (print)

输出：

[1, 30, 30]
[1.5, 25, 25]

如果变量列表大小不确定，遍历迭代是安全的，因为我只会访问已存在的索引。

- Nikolas Charalambidis

---

你可以通过一开始就使用 Math.min 来完全删除 filter。此外，收集没有任何实际好处。因为你可以使用 .forEach 在流上迭代。 - Lino

Answer 3

无需使用流 - 只需转置列表：

private static class Transpose<T> extends AbstractList<List<T>> implements List<List<T>> {
    private final List<T> [] lists;
    public Transpose(List<T>... lists) {
        this.lists = lists;
    }

    private class Column extends AbstractList<T> implements List<T> {
        private final int column;

        public Column(int column) {
            this.column = column;
        }

        @Override
        public T get(int row) {
            return lists[row].get(column);
        }

        @Override
        public int size() {
            return lists.length;
        }
    }
    @Override
    public List<T> get(int column) {
        return new Column(column);
    }

    @Override
    public int size() {
        return lists[0].size();
    }
}

private void test() {
    List<Double> list1= Arrays.asList(1.0, 1.5);
    List<Double> list2= Arrays.asList(30.0, 25.0);
    List<Double> list3= Arrays.asList(30.0, 25.0);

    List<List<Double>> matrix = new Transpose(list1, list2, list3);
    System.out.println(matrix);
}

输出：

[[1.0，30.0，30.0]，[1.5，25.0，25.0]]

如果列表的长度不相同，则这将更加困难。

- OldCurmudgeon

Answer 4

这个可以在列表大小相同或不同的情况下使用：

List<Double> list1 = List.of(1D, 1.5D);
List<Double> list2 = List.of(30D, 25D);
List<Double> list3 = List.of(30D, 25D);
Stream<List<Double>> listStream = Stream.of(list1, list2, list3);

int maxSize = listStream.mapToInt(List::size).max().orElse(0);

IntStream.range(0, maxSize)
        .forEach(index -> {
            listStream
                    .filter(list -> list.size() > index)
                    .forEach(list -> System.out.print(list.get(index) + " "));
            System.out.println();
        });

- xingbin