java将列表迭代器重置为列表的第一个元素

Question

我需要知道如何“重置”LinkedList迭代器到它的第一个元素

例如：

LinkedList<String> list;

Iterator iter=list.listIterator;

iter.next();

iter.next();

在迭代器多次移动之后，我需要一次又一次地“重置”迭代器的位置。 `

我想问一下如何将迭代器“重置”为第一个元素

我知道我可以通过以下方式获得第一个元素的列表迭代器：

iter= list.listIterator(1);

这是最好的解决方案吗？或者我在Oracle文档中遗漏了什么

Answer 1

在集合impl上调用iterator()，可能会在每次调用中得到一个新的迭代器

因此，您只需再次调用iterator()即可获得一个新的

---

代码

迭代学习。java

import org.testng.Assert;
import org.testng.annotations.Test;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;

/**
 * Iterator learn.
 *
 * @author eric
 * @date 12/30/18 4:03 PM
 */
public class IteratorLearn {
    @Test
    public void test() {
        Collection<Integer> c = new HashSet<>();
        for (int i = 0; i < 10; i++) {
            c.add(i);
        }

        Iterator it;

        // iterate,
        it = c.iterator();
        System.out.println("\niterate:");
        while (it.hasNext()) {
            System.out.printf("\t%d\n", it.next());
        }
        Assert.assertFalse(it.hasNext());

        // consume,
        it = c.iterator();
        System.out.println("\nconsume elements:");
        it.forEachRemaining(ele -> System.out.printf("\t%d\n", ele));
        Assert.assertFalse(it.hasNext());
    }
}

输出：

iterate:
    0
    1
    2
    3
    4
    5
    6
    7
    8
    9

consume elements:
    0
    1
    2
    3
    4
    5
    6
    7
    8
    9

Answer 2

最好不要使用LinkedList，通常它在所有学科中都比较慢，而且不太方便。（主要在前端插入/删除时，尤其是对于大型阵列，LinkedList速度更快）

使用ArrayList，并使用

int len = list.size();
for (int i = 0; i < len; i++) {
  Element ele = list.get(i);
}

重置很简单，只需再次循环即可
如果坚持使用迭代器，则必须使用新的迭代器：

iter = list.listIterator();

（我一生中只见过一次LinkedList的优点：我可以循环which while循环并删除第一个元素）

Answer 3

您可以再次调用listIterator方法以获取指向列表开头的迭代器实例：

iter = list.listIterator();

Answer 4

这是另一种解决方案，但有人可能会说，它没有增加足够的价值，使其值得：

import com.google.common.collect.Iterables;
...
Iterator<String> iter = Iterables.cycle(list).iterator();
if(iter.hasNext()) {
    str = iter.next();
}

调用hasNext（）会将迭代器光标重置为起始位置（如果它是结束位置）

Answer 5

如果顺序不重要，我们可以使用相同的迭代器使用hasPrevious()和previous()方法向后重新迭代：

ListIterator<T> lit = myList.listIterator(); // create just one iterator

最初迭代器位于开始处，我们进行向前迭代：

while (lit.hasNext()) process(lit.next()); // begin -> end

然后迭代器位于末尾，我们可以执行向后迭代：

while (lit.hasPrevious()) process2(lit.previous()); // end -> begin

Answer 6

实际上，您可能需要使用一个Iterable，它可以通过调用iterator()多次返回一个新的Iterator

//A function that needs to iterate multiple times can be given one Iterable:
public void func(Iterable<Type> ible) {
    Iterator<Type> it = ible.iterator(); //Gets an iterator
    while (it.hasNext()) {
        it.next();
    }
    it = ible.iterator(); //Gets a NEW iterator, also from the beginning
    while (it.hasNext()) {
        it.next();
    }
}

您必须预先定义iterator()方法执行的操作一次：

void main() {
    LinkedList<String> list; //This could be any type of object that has an iterator
    //Define an Iterable that knows how to retrieve a fresh iterator
    Iterable<Type> ible = new Iterable<Type>() {
        @Override
        public Iterator<Type> iterator() {
            return list.listIterator(); //Define how to get a fresh iterator from any object
        }
    };
    //Now with a single instance of an Iterable,
    func(ible); //you can iterate through it multiple times.
}