Java—迭代列表中的每两个元素

在同时处理两个元素时，迭代列表的最佳方式是什么

例如：

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 3] - Second [item 4]

---

您需要修改并递增

i

对于第二个值，请修改语句：

second = strings.get(i + 1);

到

这也将增加

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

List strings=Arrays.asList（“第1项”、“第2项”、“第3项”、“第4项”）；
对于（int i=0；ii+1）{
second=strings.get（++i）；//在这里更改
}
System.out.println（“第一[“+First+”]-第二[“+Second+”]）；
}

如果在每次迭代中将i增加2会怎么样？应该做。。。

---

否则考虑在实际循环内增加i i＜P＞P＞仅增加<代码> i <代码> 2：

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

for（int i=0；i

for（int i=0；ii）{
second=strings.get（i）；
}
System.out.println（“第一[“+First+”]-第二[“+Second+”]）；
}

List strings=Arrays.asList（“第1项”、“第2项”、“第3项”、“第4项”）；
int i=0；
对于（；i

List strings=Arrays.asList（“第1项”、“第2项”、“第3项”、“第4项”）；
对于（int i=0；i

为了提高性能，我建议您只计算一个列表的大小，而不要在每个新循环中创建一个新字符串

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){
    ...
}

List strings=Arrays.asList（“第1项”、“第2项”、“第3项”、“第4项”）；
int length=strings.size（）；
第一个字符串，第二个=null；
对于（int i=0；i

我们当然应该为一般情况提供解决方案；-）

publicstaticvoidmain（字符串[]args）{
List=Arrays.asList（新的整数[]{1,2,3,4,5,6,7,8,9}）；
用于（对p：对结束（列表））{
System.out.printf（“%d，%d\n”，p.first，p.second）；
}
}
静态类对{
T第一；
T秒；
公共对（T第一，T第二）{
this.first=first；
这个秒=秒；
}
公共静态Iterable over（集合集合）{
返回新的成对（集合）；
}
私有静态类PairWise实现了Iterable、迭代器{
最终迭代器；
成对（收集）{
超级（）；
this.iterator=collection.iterator（）；
}
@凌驾
公共迭代器迭代器（）{
归还这个；
}
@凌驾
公共布尔hasNext（）{
返回iterator.hasNext（）；
}
@凌驾
公共对下一个（）{
T first=null；
T秒=零；
if（iterator.hasNext（））
first=迭代器.next（）；
其他的
抛出新的NoTouchElementException（）；
if（iterator.hasNext（））
second=迭代器.next（）；
返回新的一对（第一，第二）；
}
@凌驾
公共空间删除（）{
抛出新的UnsupportedOperationException（）；
}
}
}

您可以避免使用索引；这适用于任何对象，而不仅仅是列表。只需获取一个迭代器，并在每次循环迭代中增加两次：

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

迭代器使一些人感到困惑，因此您也可以使用带有分支的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 strings=Arrays.asList（“第1项”、“第2项”、“第3项”、“第4项”）；
布尔值isFirst=true；
字符串first=null；
字符串秒=空；
for（字符串：字符串）{
如果（isFirst）{
第一个=字符串；
isFirst=false；
}否则{
第二个=字符串；
isFirst=true；
System.out.println（“第一[“+First+”]-第二[“+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 + "]");
  }
}

List strings=Arrays.asList（“第1项”、“第2项”、“第3项”、“第4项”）；
{
迭代器stringsIterator=strings.Iterator（）；
while（stringsIterator.hasNext（））{
String first=stringsIterator.next（）；
String second=stringsIterator.next（）；
System.out.println（“第一[“+First+”]-第二[“+Second+”]）；
}
}

现在在Java 8中，通过使用

你可以写：

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

---

我使用Java8双消费者创建了以下方法：

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

---

我只会在for语句的第三部分中不断更改索引变量。在循环中的多个位置增加索引变量会导致代码不太清晰（这意味着更难理解和维护，更容易出现错误）。这是for循环中非常常见的习惯用法/经验法则，而如果您确实编写了for循环，则循环可能是更好的选择

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

    }
}

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

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

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

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

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