Java - Iterieren über alle zwei Elemente in einer Liste

Question

Was ist der beste Weg, um eine Liste während der Verarbeitung von 2 Elementen gleichzeitig zu durchlaufen?

Beispiel:

List<String> strings = Arrays.asList("item 1", "item 2", "item 3", "item 4"); 
for(int i = 0; i < strings.size(); i++){ 
    String first = strings.get(i); 
    String second = null; 
    if(strings.size() > i + 1){ 
     second = strings.get(i + 1); 
    } 
    System.out.println("First [" + first + "] - Second [" + second + "]"); 
} 

Ergebnisse in:

First [item 1] - Second [item 2] 
First [item 2] - Second [item 3] 
First [item 3] - Second [item 4] 
First [item 4] - Second [null] 

Ich mag würde erreichen:

First [item 1] - Second [item 2] 
First [item 3] - Second [item 4] 

Answer 1

Gerade i erhöhen 2:

for(int i = 0; i < strings.size(); i += 2) { 

Answer 2

Sie benötigen i für den zweiten Wert zu ändern und zu erhöhen, ändern Sie die Aussage:

second = strings.get(i + 1); 

zu

second = strings.get(++i); 

Dies wird die i auch erhöhen, da dies das gewünschte Verhalten zu sein scheint.

So würde Ihr Code sein:

List<String> strings = Arrays.asList("item 1", "item 2", "item 3", "item 4"); 
for(int i = 0; i < strings.size(); i++){ 
    String first = strings.get(i); 
    String second = null; 
    if(strings.size() > i + 1){ 
     second = strings.get(++i); //Change here 
    } 
    System.out.println("First [" + first + "] - Second [" + second + "]"); 
} 

Answer 3

Was ist, wenn Sie i in jeder Iteration um 2 erhöhen? Sollte tun ... Andernfalls i innerhalb der eigentlichen Schleife erhöhen

Answer 4

for(int i = 0; i < strings.size(); i++){ 
    String first = strings.get(i++); 
    String second = null; 
    if(strings.size() > i){ 
     second = strings.get(i); 
    } 
    System.out.println("First [" + first + "] - Second [" + second + "]"); 
} 

Answer 5

List<String> strings = Arrays.asList("item 1", "item 2", "item 3", "item 4");  
int i = 0; 
for(; i < strings.size() - 1; i+=2){ 
    String first = strings.get(i); 
    String second = strings.get(i + 1); 
    System.out.println("First [" + first + "] - Second [" + second + "]"); 
} 
//For odd sized lists 
if(i < strings.size()){   
    System.out.println("First [" + strings.get(i) + "]"); 
} 

Answer 6

List<String> strings = Arrays.asList("item 1", "item 2", "item 3", "item 4"); 
for(int i = 0; i < strings.size(); i++){ 
    if(i½2 = 0){ 
     String first = strings.get(i); 
     System.out.print("First [" + first + "] "); 
    }else{ 
     String second = strings.get(i + 1); 
     System.out.println("- Second [" + second + "]"); 
    } 
} 

Answer 7

Für Leistung, werde ich empfehlen Ihnen, die zu berechnen Größe der Liste nur eine und keine neue Zeichenfolge bei jeder neuen Schleife erstellen.

List<String> strings = Arrays.asList("item 1", "item 2", "item 3", "item 4"); 
int length = strings.size(); 
String first, second = null; 
for(int i = 0; i < length; i += 2){ 
    ... 
} 

Answer 8

Wir sollten natürlich eine Lösung für den allgemeinen Fall liefern ;-)

public static void main(String[] args) { 
    List<Integer> list = Arrays.asList(new Integer[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 }); 
    for (Pair<Integer> p : Pair.over(list)) { 
     System.out.printf("%d, %d\n", p.first, p.second); 
    } 
} 

static class Pair<T> { 
    T first; 

    T second; 

    public Pair(T first, T second) { 
     this.first = first; 
     this.second = second; 
    } 

    public static <T> Iterable<Pair<T>> over(Collection<T> collection) { 
     return new PairWise<T>(collection); 
    } 

    private static class PairWise<T> implements Iterable<Pair<T>>, Iterator<Pair<T>> { 

     final Iterator<T> iterator; 

     PairWise(Collection<T> collection) { 
      super(); 
      this.iterator = collection.iterator(); 
     } 

     @Override 
     public Iterator<Pair<T>> iterator() { 
      return this; 
     } 

     @Override 
     public boolean hasNext() { 
      return iterator.hasNext(); 
     } 

     @Override 
     public Pair<T> next() { 
      T first = null; 
      T second = null; 
      if (iterator.hasNext()) 
       first = iterator.next(); 
      else 
       throw new NoSuchElementException(); 
      if (iterator.hasNext()) 
       second = iterator.next(); 
      return new Pair<T>(first, second); 
     } 

     @Override 
     public void remove() { 
      throw new UnsupportedOperationException(); 
     } 

    } 
} 

Answer 9

Sie Indizierung mit einem Iterator vermeiden können; Dies funktioniert für jede Iterable, nicht nur eine Liste. Nur einen Iterator bekommen und es zweimal pro Schleife erhöhen Iteration:

List<String> strings = Arrays.asList("item 1", "item 2", "item 3", "item 4"); 
Iterator<String> stringsIterator = strings.iterator(); 
while (stringsIterator.hasNext()) { 
    String first = stringsIterator.next(); 
    String second = stringsIterator.next(); 
    System.out.println("First [" + first + "] - Second [" + second + "]"); 
} 

Dies setzt voraus, eine Liste von gleicher Länge und wirft NoSuchElementException am letzten Pass, wenn sie ungerade Länge ist. Sie können dies auf verschiedene Weise handhaben:

• eine try verwenden - catch;
• haben eine Wächterklausel, die überprüft, dass die Länge gerade vorher ist;
• überprüfen, bevor Sie das zweite Element erhalten.

Überprüfen des zweiten Elements:

List<String> strings = Arrays.asList("item 1", "item 2", "item 3"); 
Iterator<String> stringsIterator = strings.iterator(); 
while (stringsIterator.hasNext()) { 
    String first = stringsIterator.next(); 
    String second = stringIterator.hasNext() ? stringIterator.next() : null; 
    System.out.println("First [" + first + "] - Second [" + second + "]"); 
} 

Iteratoren einige Leute verwirren, so dass Sie auch eine für-jede Schleife mit einem Zweig und einem Hilfs Flip-Flop-Variable für die Parität verwenden können. Dies ist viel schlimmer, da es die Logik der Schleife viel komplizierter macht, um die Iteration zu vereinfachen: anstatt die Aktion einmal pro Durchgang durch die Schleife nacheinander und ohne Verzweigung durchzuführen, müssen Sie sie stattdessen zweimal durchlaufen und mental verzweigen. Beachten Sie, dass dies das letzte Element überspringt, wenn es eine ungerade Länge hat; könnte nachträglich eine Überprüfung von isFirst hinzufügen, wenn auch diese Fälle behandelt werden sollen.

List<String> strings = Arrays.asList("item 1", "item 2", "item 3", "item 4"); 
boolean isFirst = true; 
String first = null; 
String second = null; 
for (String string : strings) { 
    if (isFirst) { 
    first = string; 
    isFirst = false; 
    } else { 
    second = string; 
    isFirst = true; 
    System.out.println("First [" + first + "] - Second [" + second + "]"); 
    } 
} 

Schließlich beachten Sie, dass alle diese Iteratoren und Hilfsgrößen haben überschüssigen Umfang (sie nur dann von Nutzen für die Schleife selbst sind, so dass sie verschmutzen die lokale Umgebung): sie in Blöcken eingewickelt werden, um den Umfang zu begrenzen, obwohl in der Regel wird die resultierende Verschachtelung schlechter angesehen als der Überschuss -umfang:

List<String> strings = Arrays.asList("item 1", "item 2", "item 3", "item 4"); 
{ 
    Iterator<String> stringsIterator = strings.iterator(); 
    while (stringsIterator.hasNext()) { 
    String first = stringsIterator.next(); 
    String second = stringsIterator.next(); 
    System.out.println("First [" + first + "] - Second [" + second + "]"); 
    } 
} 

Answer 10

Jetzt in Java 8, https://github.com/wapatesh/fig

verwenden, können Sie schreiben:

seq.forEachSlice(2, (values)->{ 
    // [1,2] [3, 4] 
}); 

Answer 11

Ich habe die folgende Methode ein Java8 BiConsumer mit:

public static <T> void tupleIterator(Iterable<T> iterable, BiConsumer<T, T> consumer) { 
    Iterator<T> it = iterable.iterator(); 
    if(!it.hasNext()) return; 
    T first = it.next(); 

    while(it.hasNext()) { 
     T next = it.next(); 
     consumer.accept(first, next); 
     first = next; 
    } 
} 

es wie folgt verwendet werden:

List<String> myIterable = Arrays.asList("1", "2", "3"); 
tupleIterator(myIterable, (obj1, obj2) -> { 
    System.out.println(obj1 + " " + obj2); 
}); 

erhalten Sie folgende Ausgabe:

1 2 
2 3