如何在Java中通过泛型与Iterable实现Python风格的并行for迭代

你的现有实现已经完成了固定List类型的同步遍历逻辑，要适配任意数量的Iterable输入，只需要把底层存储的List<List<T>>替换为所有输入Iterable对应的迭代器实例即可，具体改进如下： #

1. 核心改进点 #

• 入参从List<T>...修改为Iterable<? extends T>...，支持任意实现了Iterable接口的集合/自定义类型输入
• 构造阶段就把所有输入的Iterable转换为Iterator存储，避免重复获取迭代器导致的遍历重置问题
• 可自由选择遍历终止逻辑：
  • 短对齐（Python原生zip逻辑）：所有输入中最短的遍历完就终止，不会补空值
  • 长对齐（你的原始逻辑）：最长的输入遍历完才终止，短输入超出的位置补null

2. 完整可运行代码 #

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Arrays;

public class ParallelIterable<T> implements Iterable<List<T>> {
    private final List<Iterator<? extends T>> iterators;

    // 支持传入任意数量的Iterable实例
    @SafeVarargs
    public ParallelIterable(Iterable<? extends T>... inputs) {
        iterators = new ArrayList<>(inputs.length);
        for (Iterable<? extends T> input : inputs) {
            iterators.add(input.iterator());
        }
    }

    @Override
    public Iterator<List<T>> iterator() {
        return new Iterator<List<T>>() {
            // 长对齐模式的hasNext，只要有一个迭代器还有元素就返回true
            @Override
            public boolean hasNext() {
                for (Iterator<? extends T> it : iterators) {
                    if (it.hasNext()) {
                        return true;
                    }
                }
                return false;
            }

            // 如果要改成短对齐（和Python zip一致），把hasNext替换成下面的实现：
            // @Override
            // public boolean hasNext() {
            //     for (Iterator<? extends T> it : iterators) {
            //         if (!it.hasNext()) {
            //             return false;
            //         }
            //     }
            //     return true;
            // }

            @Override
            public List<T> next() {
                List<T> current = new ArrayList<>(iterators.size());
                for (Iterator<? extends T> it : iterators) {
                    current.add(it.hasNext() ? it.next() : null);
                }
                return current;
            }

            @Override
            public void remove() {
                for (Iterator<? extends T> it : iterators) {
                    it.remove();
                }
            }
        };
    }

    // 使用示例
    public static void main(String[] args) {
        List<Integer> foo = Arrays.asList(1, 2, 3);
        List<Integer> bar = Arrays.asList(4, 5, 6);
        // 支持任意数量输入，比如这里可以再加第三个、第四个Iterable
        ParallelIterable<Integer> parallel = new ParallelIterable<>(foo, bar);
        for (List<Integer> item : parallel) {
            System.out.printf("f: %s ; b: %s%n", item.get(0), item.get(1));
        }
    }
}

3. 运行输出 #

和你给出的Python示例效果完全一致：

f: 1 ; b: 4
f: 2 ; b: 5
f: 3 ; b: 6

内容的提问来源于stack exchange，提问作者DavidRYV