问题描述

假设我有这个:

public class Unit<MobileSuit, Pilot> {

    ...

    List<MobileSuit> mobileSuits;
    List<Pilot> pilots;

    ...
}

并且我想在该类之外以最简单的方式遍历这对.我该怎么做呢?我想过这样做:

And I would like to iterate through the pair of each in the simplest way outside of that class. How should I go about doing that? I thought about doing this:

public class Unit<MobileSuit, Pilot> {

    ...
    Iterator<MobileSuit> iteratinMechas;
    Iterator<Pilot> iteratinPeople;

    class IteratorCustom<MobileSuit, Pilot> implements Iterator {

        public boolean hasNext() {
            return iteratinMechas.hasNext() && iteratinPeople.hasNext();
        }

        public void remove() {
            iteratinMechas.remove();
            iteratinPeople.remove();
        }

        public Object next() {
            // /!
        }

    }

    public Iterator iterator() {
        return new IteratorCustom<MobileSuit, Pilot>(mobileSuits, pilots);
    }
}

类似的东西.

无论如何，问题是我不能真正从 next() 返回单个对象，而且我也不能让迭代器采用多种类型.那么，有什么想法吗?

Anyway, the problem is that I can't really return just a single object from next(), and I also can't have a Iterator take more than one type. So, any thoughts?

另外，我无法创建一个新课程来结合 MobileSuit 和 Pilot.我需要将它们分开，即使我一次遍历两者.原因是可能有没有飞行员的机动战士，我不确定如何通过将它们保持在同一级别来解决这个问题.这个类需要在其他地方处理，所以我必须围绕它和很多其他东西统一一个接口.基本上，假设 MobileSuit 和 Pilot 需要分开.

Also, I can't make a new class to combine MobileSuit and Pilot. I need to keep them separate, even though I'm iterating through both at a time. The reason is that there might be Mobile Suits that have no pilots, and I'm not sure how to fix that by keeping them at the same class. This class needs to be processed in other places, so I'd have to unify a interface around that and a lot of other stuff. Basically, assume MobileSuit and Pilot need to be separated.

推荐答案

无论如何，问题是我不能真正从 next() 返回单个对象，而且我也不能让迭代器采用多种类型.那么，有什么想法吗?

Anyway, the problem is that I can't really return just a single object from next(), and I also can't have a Iterator take more than one type. So, any thoughts?

显然，您将需要一个轻量级的pair"类.这大致类似于 Map.Entry 内部类.

Obviously you are going to need a light-weight "pair" class. This is roughly analogous to the Map.Entry inner class.

这是一个通用解决方案的粗略:

Here's a rough cut at a generic solution:

public class ParallelIterator <T1, T2> implements Iterator<Pair<T1, T2>> {

    public class Pair<TT1, TT2> {
        private final TT1 v1;
        private final TT2 v2;
        private Pair(TT1 v1, TT2 v2) { this.v1 = v1; this.v2 = v2; }
        ...
    }

    private final Iterator<T1> it1;
    private final Iterator<T2> it2;

    public ParallelIterator(Iterator<T1> it1, Iterator<T2> it2) { 
        this.it1 = it1; this.it2 = it2;
    }

    public boolean hasNext() { return it1.hasNext() && it2.hasNext(); }

    public Pair<T1, T2> next() {
        return new Pair<T1, T2>(it1.next(), it2.next());
    }

    ...

}

注意:这并没有明确处理列表长度不同的情况.将会发生的情况是，较长列表末尾的额外元素将被静默忽略.

Note: this doesn't explicitly deal with cases where the lists have different lengths. What will happen is that extra elements at the end of the longer list will be silently ignored.

这篇关于同时提供两个列表内容的迭代器?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持跟版网！