Java 在这种情况下如何使用迭代器？

我必须以这种方式迭代arraylist

ArrayList<Integer> li = new ArrayList<Integer>();
li.add(20);
li.add(30);
li.add(40);
li.add(50);
li.add(70);

for (int i = 0; i < li.size() - 1; i++)
    System.out.println(li.get(i) + " " + li.get(i + 1));

---

如何使用迭代器进行同样的操作？

这有点复杂：

Iterator<Integer> iter = li.iterator();
if (iter.hasNext()) {
    for (int y = iter.next(), x; iter.hasNext(); y = x) {
        x = iter.next();
        System.out.println(y + " " + x);
    }
}

---

使用两个迭代器。我测试了这个，它对我有效

    Iterator<Integer> first = li.listIterator();

    // Will raise IndexOutOfBoundsException if list is empty.
    Iterator<Integer> second = li.listIterator(1);

    while (second.hasNext()) {
        System.out.println(first.next() + " " + second.next());
    }

Iterator first=li.listIterator（）；
//如果列表为空，将引发IndexOutOfBoundsException。
迭代器秒=li.listIterator（1）；
while（second.hasNext（））{
System.out.println（first.next（）+“”+second.next（））；
}

编辑：如果，则不需要内部

。我真傻

说明：
listIterator（index）
方法返回从列表中指定位置开始的迭代器，其中as
listIterator（）
返回从位置0开始的迭代器

因此，
第一个
迭代器从
0
开始，
第二个
从
1
开始。然后，这仅仅是在两个屏幕上打印
next（）
的问题。无论列表中的元素数是奇数还是偶数，这都将起作用

编辑2

今天我的逻辑很弱。感谢您指出空列表和不必要的
first.hasNext（）
 稍微修改了Sagar V的解决方案，使其起作用。一个迭代器就足以实现这一点

Iterator iter = li.iterator();
        Integer int1 = null;

        while (iter.hasNext()) {
            if (int1 == null) {
                int1 = (Integer) iter.next();
            }

            System.out.print(int1 + " ");
            if (iter.hasNext()) {
                Integer int2 = (Integer) iter.next();
                System.out.println(int2);
                int1 = int2;
            } else {
                break;
            }
        }
    }

根据您的需要，有许多解决方案是合适的

解决方案1：固定大小视图
迭代列表子集的经典方法是创建原始列表的较窄视图，然后迭代整个视图。
子列表
方法用于创建这样的视图

List<Integer> l = // initialization code

int limitIndex = Math.max(l.size()-1, 0); // needed for empty list
for (int v : l.subList(0, limitIndex)) {
    // your code
}

此类的使用方式如下：

for (int v : new NoLastIterable<Integer>(l)) {
    // your code
}

与其他解决方案的用法相同：

for (int v : new NoLastList<Integer>(l)) {
    // your code
}

for（int v：新的NoLastList（l））{
//你的代码
}

此解决方案的好处可以在以下情况下看到：

将创建并初始化原始列表
创建
NoLastList
实例（作为原始列表的视图）
一些元素被添加到原始列表中
在这种情况下，迭代
NoLastList
将考虑最近添加的元素
NoLastList
始终表示从0到n-1的元素视图，即使n（大小）发生变化。
如果列表中的项目数为奇数，则在没有hasNext（）检查的情况下，.next（）调用可能会抛出NoSuchElementException。这假设迭代器中的项始终为偶数。在每次调用next（）之前，都会进行hasNext（）检查。这两个选项可以正确处理任意数量的条目（0、1、2、3、4、5、6、7等）。好吧，如果你不相信我，你自己试试看。第二个有点冒险，因为它依赖于从左到右的求值顺序，字符串连接才能正常工作。。。我知道Java规范保证了这一点，但这仍然是一种不推荐的做法（）1）如果列表为空，则此代码不起作用。2） 
first.hasNext（）
无效，您可以将其删除。3） 需要注意的一点是，对
next（）
的两个调用是必要的，即使没有使用返回值。
Iterator<Integer> it = l.subList(0, limitIndex).iterator();
while(it.hasNext()) {
    int v = it.next();
    // your code
}

public class NoLastIterable<T> implements Iterable<T> {

    private final List<T> backend;

    public NoLastIterable(List<T> backend) {
        this.backend = backend;
    }

    public Iterator<T> iterator() {
        return new Iterator<T>() {

            private int nextIndex;

            public boolean hasNext() {
                return nextIndex < backend.size() -1;
            }

            public T next() {
                return backend.get(nextIndex++);
            }

            public void remove() {
                throw new UnsupportedOperationException("not implemented");
            }

        };
    }
}

for (int v : new NoLastIterable<Integer>(l)) {
    // your code
}

public class NoLastList<T> extends AbstractList<T> {

    private final List<T> backend;

    public NoLastList(List<T> backend) {
        this.backend = backend;
    }

    @Override
    public T get(int index) {
        if (index >= size()) {
            throw new IndexOutOfBoundsException();
        }
        return backend.get(index);
    }

    @Override
    public int size() {
        return Math.max(0, backend.size()-1);
    }

}

for (int v : new NoLastList<Integer>(l)) {
    // your code
}