你可以再次调用listIterator方法来获得一个指向list开头的迭代器示例：

iter = list.listIterator();

最好是根本不使用LinkedList，通常它在所有领域都比较慢，而且不方便（主要是在前面插入/删除时，特别是对于大数组，LinkedList比较快）
使用ArrayList，并使用迭代

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

重置是微不足道的，只需再次循环即可。
如果你坚持使用迭代器，那么你必须使用一个新的迭代器：

iter = list.listIterator();

（我一生中只见过一次LinkedIn的优势：我可以用while循环遍历并删除第一个元素）

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

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

调用hasNext（）会将迭代器光标重置到开头（如果它是结尾）。

实际上，您可能需要使用一个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.
}

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

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

最初，迭代器位于开始位置，我们进行 forward 迭代：

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

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

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

在Collection impl上调用iterator()，可能会在每次调用时获得一个新的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

你可以做的是，用while循环手动地将迭代器设置到第一个位置。

while(iter.hasPrevious())
{
    iter.previous();
}

当你退出循环时，你的迭代器会在位置0

抱歉有任何语法错误

有些版本的java没有重置迭代器的方法，所以我们需要使用多个迭代器，这最终会增加内存消耗。
所以如果需要的话，通过声明一个全局函数并将集合作为参数传递，再次使用相同的迭代器是一种简单的方法。
例如enter image description here
例如（书面程序）包com。javalearn;
导入java.util.ArrayList;导入java.util.Iterator;
公共类Java学习{

public static void main(String[] args) {
            ArrayList<String> list = new ArrayList<String>();
            list.add("Hello");
            list.add("World");
            list.add("It's");
            list.add("me.");

            iter(list);

            System.out.println(list.size());
            System.out.println(list.indexOf("me."));
            System.out.println(list.remove(3));

            iter(list);
    }
    static void iter(ArrayList<String> arr){
            Iterator itr = arr.iterator();
            while(itr.hasNext()){
                    System.out.println(itr.next());
            }
    }

}