java是迭代两个相关数组列表的有效方法？

Question

我正在寻找一种干净简单的方法来迭代两个直接相关的ArrayList，其中一个的每个索引都映射到另一个的索引（在关系中）

目前，我正在通过一个简单的for循环来实现这一点，我尝试研究lambdas和for-each循环，但没有发现一种方法可以同时将其应用于大小相同的两个列表

第一个列表：["Blue", "Red", "Green"]

第二个列表：["Sky", "Roses", "Grass"]

for(int i = 0; i < firstList.size(); i++){
    System.out.println(firstList.get(i) + " " + secondList.get(i));
}

结果：

Blue Sky
Red Roses
Green Grass

有没有一种方法可以有效地使用lambda或for-each循环同时迭代两个列表，以避免使用for循环

Answer 1

你所拥有的已经相当高效（假设你使用的是ArrayList），简洁易读。然而，这种情况：

I am looking for a clean and simple way to iterate over two ArrayLists that are related directly in that each index of one maps to the index of another (in relationship).

通常需要定义关系的类，在您的情况下：

public class MyC {
    private final String color;
    private final String object;

    public MyC(String color, String object) {
        this.color = color;
        this.object = object;
    }
    public String getColor(){
        return color;
    }
    public String getObject(){
        return object;
    }

    @Override
    public String toString() {
        return "MyC{" +
                "color='" + color + '\'' +
                ", object='" + object + '\'' +
                '}';
    }
} 

然后这两个列表将成为一个：

List<MyC> list = List.of(new MyC("Blue", "Sky"), new MyC("Red", "Roses"), new MyC("Green", "Grass") );

然后你可以使用：

list.forEach(System.out::println);

Answer 2

所有其他答案都是正确的，首选的解决方案应该始终是@Basil Bourque所示的解决方案，但正如其他人在评论中指出的那样，使用索引迭代非基于数组的列表并不是非常有效。然而，使用迭代器进行迭代（每个实现都可以提供一个有效的实现）应该是可行的

下面是一个使用迭代器迭代两个列表的示例：

import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.function.BiConsumer;

public class IterateTwoListsExample {

    public static void main(String[] args) {
        List<String> firstList = Arrays.asList("Blue","Red","Green");
        List<String> secondList = Arrays.asList("Sky","Roses","Grass");

        forEach(firstList, secondList, (first, second) -> System.out.printf("%s %s%n", first, second));
    }

    public static <T0, T1> void forEach(List<? extends T0> first, List<? extends T1> second, BiConsumer<? super T0, ? super T1> consumer) {
        final Iterator<? extends T0> firstIt = first.iterator();
        final Iterator<? extends T1> secondIt = second.iterator();

        while (firstIt.hasNext() && secondIt.hasNext()) {
            consumer.accept(firstIt.next(), secondIt.next());
        }
    }
}