Java - 迭代列表中的每兩個元素

Question

在處理2個元素的同時迭代列表的最佳方式是什麼？

實例：

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 + "]"); 
} 

結果：

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

我想實現：

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

Answer 1

只是增加i以2：

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

Answer 2

您需要修改和增加i第二值，修改聲明：

second = strings.get(i + 1); 

到

second = strings.get(++i); 

這將遞增i爲好，因爲這似乎是期望的行爲。

所以，你的代碼是：

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

如果你在每次迭代增加我的2？應該做的...... 否則考慮提高我的實際循環內

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

出於性能考慮，我會建議你來計算列表大小隻有一個，並且不會在每個新循環中創建一個新字符串。

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

我們當然應該提供一般情況下;-)

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

可避免與Iterator索引的解決方案;這適用於任何Iterable，而不僅僅是一個列表。剛剛得到一個迭代，每個循環迭代增加了兩遍：

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 + "]"); 
} 

這是假設，即使長的列表，並在最後一關拋出NoSuchElementException，如果是奇數長度。您可以通過多種方式處理：

• 使用try - catch;
• 有一個保護條款，它會檢查長度是否在預先確定的範圍內;
• 獲取第二個元素之前檢查。

檢查第二個元素：

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 + "]"); 
} 

迭代迷惑一些人，所以你也可以使用for-each循環用樹枝和奇偶校驗輔助觸發器變​​量。這更糟糕，因爲它使得循環的邏輯更加複雜以簡化迭代：而不是每次通過循環執行一次操作，而是按順序進行並且不需要分支，而是必須經過兩次並在心理上分支。請注意，如果它的長度爲奇數，則會跳過最後一個元素;如果想要處理這些情況，可以在之後添加isFirst的支票。

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 + "]"); 
    } 
} 

最後，注意，所有這些迭代器和輔助變量有多餘範圍（他們只使用了循環本身的，所以他們污染了當地的環境）：可以把它們包裹在塊限制範圍，雖然平時所產生的嵌套被認爲比超出範圍更糟：

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

現在的Java 8，使用https://github.com/wapatesh/fig

你可以寫：

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

Answer 11

我創建使用Java8 BiConsumer以下方法：

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; 
    } 
} 

這樣使用它：

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

這將輸出：

1 2 
2 3