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

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

例如：

LinkedList列表

Iterator iter=list.listIterator

iter.next（）

iter.next（）

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

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

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

iter=list.listIterator（1）

这是最好的解决方案吗？或者我在Oracle文档中遗漏了什么
 您可以再次调用
listIterator
方法以获取指向列表开头的迭代器实例：

iter = list.listIterator();

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

使用
ArrayList
，并使用

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

（我一生中只见过一次LinkedList的优点：我可以循环which while循环并删除第一个元素）
如果顺序不重要，我们可以使用相同的迭代器使用
hasPrevious（）
和
previous（）
方法重新向后迭代：

ListIterator lit=myList.ListIterator（）；//只创建一个迭代器

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

while（lit.hasNext（））进程（lit.next（））；//开始->结束

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

while（lit.hasPrevious（））process2（lit.previous（））；//结束->开始
这是另一种解决方案，但有人可能会说它没有增加足够的价值，使其值得：

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

import com.google.common.collect.Iterables；
...
迭代器iter=Iterables.cycle（list.Iterator（）；
if（iter.hasNext（））{
str=iter.next（）；
}

调用hasNext（）会将迭代器光标重置为开始位置（如果它是结束位置）。
在集合impl上调用
iterator（）
，可能会在每次调用时得到一个新的迭代器

因此，您只需再次调用
iterator（）
，即可获得一个新的迭代器


代码
IteratorLearn.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());
    }
}

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

为什么不创建一个新的迭代器呢？好吧，你错过了一些东西，如果你需要做比下一个或者上一个更多的事情，迭代器不是最好的选择。为什么需要重置？我试图理解java中动态列表的概念。几周前，我对jsp oage上的会话变量有一个问题。从EL和taglibs中，我可以使用迭代器的方法，但我不能重新定义它（我对jsp仍然知之甚少，但我仍在改进它：））当您编写“迭代器不是最佳选择”时，您介意什么？你能给我解释一下吗？：）当删除和插入主要是在前面时，LinkedList会更快。如果是LinkedList，即使从中间删除项目也会更快。也就是说，如果您使用iterator.remove（）迭代并删除项。ArrayList需要移动剩余的项。@Sohaib，是的，主要取决于列表的大小。多达特定数量的元素System.arraycopy，它内部使用C-memcopy，用于移动数组的速度更快。高级实现根据element size.awesome切换基础实现。现在还不清楚这个调用是否只返回与您已经使用的迭代器相同的引用。但我想调查来源也能解决这个问题。这里有一个链接供任何好奇的人使用，因为这是我试图改进的一个习惯：Hmm@ryenus…我喜欢你的想法，在“向前”迭代发生后，使用hasPrevious（）和previous（）从最后一个元素向后迭代。如果您需要使用相同的迭代器实例，那么这似乎是一个完美的解决方案（但不确定为什么您实际上需要反复使用相同的实例）。我很好奇循环回到迭代的开始是否比创建一个新的迭代器实例花费更少，但我想这也在某种程度上取决于列表的大小。
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

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

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