Fournir un itérateur sur le contenu des deux listes en même temps?

C'est copié+édité par Stephen C de la réponse. N'hésitez pas à utiliser:

public class Pair<T1, T2> {
private final T1 v1;
private final T2 v2;
Pair(T1 v1, T2 v2) {
this.v1 = v1;
this.v2 = v2;
}
public T1 first(){
return v1;
}
public T2 second(){
return v2;
}
}
public class ParallelIterator <T1, T2> implements Iterator<Pair<T1, T2>> {
private final Iterator<T1> it1;
private final Iterator<T2> it2;
public ParallelIterator(Iterator<T1> it1, Iterator<T2> it2) { 
this.it1 = it1; this.it2 = it2;
}
@Override
public boolean hasNext() { return it1.hasNext() && it2.hasNext(); }
@Override
public Pair<T1, T2> next() {
return new Pair<T1, T2>(it1.next(), it2.next());
}
@Override
public void remove(){
it1.remove();
it2.remove();
}
}
public class IterablePair <T1, T2> implements Iterable<Pair<T1,T2>> {
private final List<T1> first;
private final List<T2> second;
public IterablePair(List<T1> first, List<T2> second) { 
this.first = first;
this.second = second;
}
@Override
public Iterator<Pair<T1, T2>> iterator(){
return new ParallelIterator<T1,T2>( first.iterator(), second.iterator() );
}
}
void someFunction(){
IterablePair<X,Y> listPair = new IterablePair<X,Y>( x, y );
for( Pair<X,Y> pair : listPair ){
X x = pair.first();
...
}
}

Cela s'arrête dès que la liste est à partir d'éléments, de sorte que vous pourriez vouloir vérifier les listes de même taille qu'avant la création d'un IterablePair.

La raison en est qu'il peut être Mobile Costumes qui n'ont pas de pilotes, et je ne suis pas sûr de la façon de corriger cela en de les garder à la même classe.

Vous pouvez utiliser les valeurs null, droit? Qui est la façon correcte de le faire - demander à chaque fonction de garder la trace de ses pilotes. Si elle n'a pas de pilote, puis indiquer qu'avec une valeur null là.

Mais, si vous êtes ensemble mort sur de ne pas le faire pour une raison...

public class SuitAndPilot
{
public MobileSuit suit;
public Pilot pilot;
public SuitAndPilot(Suit s, Pilot p) {
suit = s;
pilot = p;
}
}

Fondamentalement, supposons MobileSuit et le Pilote doivent être séparées.

C'est très bien, mais ici vous essayez de les traiter comme une unité, de sorte que la structure de votre code de cette façon. Les suggestions ci-dessus à utiliser un Pair classe ou Map.Entry, mais c'est beaucoup mieux de fournir une clairement nommées par l'objet qui représente une MobileSuit avec un Pilot, par exemple:

public class OccupiedSuit {
private final MobileSuit suit;
private final Pilot pilot;
public OccupiedSuit(MobileSuit suit, Pilot pilot) {
this.suit = checkNotNull(suit);
this.pilot = checkNotNull(pilot);
}
//getters, equals, hashCode, toString
//or just use @AutoValue: https://github.com/google/auto/tree/master/value
}

Alors, plutôt que de construire une coutume Iterator/Iterable, il suffit d'écrire une fonction d'assistance qui zips des deux listes. Par exemple:

public static List<OccupiedSuit> assignPilots(
Iterable<MobileSuit> suits, Iterable<Pilot> pilots) {
Iterator<MobileSuit> suitsIter = suits.iterator();
Iterator<Pilot> pilotsIter = pilots.iterator();
ImmutableList.Builder<OccupiedSuit> builder = ImmutableList.builder();
while (suitsIter.hasNext() && pilotsIter.hasNext()) {
builder.add(new OccupiedSuit(suitsIter.next(), pilotsIter.next()));
}
//Most of the existing solutions fail to enforce that the lists are the same
//size. That is a *classic* source of bugs. Always enforce your invariants!
checkArgument(!suitsIter.hasNext(),
"Unexpected extra suits: %s", ImmutableList.copyOf(suitsIter));
checkArgument(!pilotsIter.hasNext(),
"Unexpected extra pilots: %s", ImmutableList.copyOf(pilotsIter));
return builder.build();
}

Maintenant, vous n'avez pas besoin de maintenir un complexe personnalisé Iterator mise en œuvre - il suffit de s'appuyer sur celui qui existe déjà!

---

On peut aussi généraliser assignPilots() dans un générique utilitaire qui fonctionne pour tout deux entrées, comme suit:

public static <L,R,M> List<M> zipLists(
BiFunction<L,R,M> factory, Iterable<L> left, Iterable<R> right) {
Iterator<L> lIter = left.iterator();
Iterator<R> rIter = right.iterator();
ImmutableList.Builder<M> builder = ImmutableList.builder();
while (lIter.hasNext() && rIter.hasNext()) {
builder.add(factory.apply(lIter.next(), rIter.next()));
}
checkArgument(!lIter.hasNext(),
"Unexpected extra left elements: %s", ImmutableList.copyOf(lIter));
checkArgument(!rIter.hasNext(),
"Unexpected extra right elements: %s", ImmutableList.copyOf(rIter));
return builder.build();
}

Qui vous devez ensuite appeler comme ceci:

List<OccupiedSuit> occupiedSuits = zipLists(OccupiedSuit::new, suits, pilots);

_{Exemple de code utilise Goyave's Preconditions et ImmutableList - si vous n'utilisez pas la Goyave il est assez facile d'en ligne et swap pour ArrayList, mais il suffit d'utiliser la Goyave 🙂}

Vous pouvez simplement utiliser un Map<MobileSuit, Pilot>, où un null valeur mappée à une MobileSuit indique pas de pilote. Le Iterator pourrait juste être un Iterator<Map.Entry<MobileSuit, Pilot>> récupérées par map.entrySet().iterator().

L'amélioration de la réponse par user2224844, voici une version simple, qui est de ne pas essayer de courir à une exception:

final Iterator<String> pilotIterator = pilots.iterator();
mobileSuits.forEach(m -> {
Pilot p = pilotIterator.hasNext()? pilotIterator.next():nullOrWahtever;
<Now do your work with m and p variables>
...
});