Java ConcurrentModificationException错误使用迭代器[.next（）]

我需要迭代器的帮助，无论我做什么，迭代器都会不断地给我错误：

Exception in thread "main" java.util.ConcurrentModificationException
 at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:859)
 at java.util.ArrayList$Itr.next(ArrayList.java:831)
 at package.Dictionary.writer(Dictionary.java:72)
 at package.main.main(main.java:24) <5 internal calls>

线程“main”java.util.ConcurrentModificationException中的异常 在java.util.ArrayList$Itr.checkForComodification（ArrayList.java:859）中 在java.util.ArrayList$Itr.next（ArrayList.java:831） at package.Dictionary.writer（Dictionary.java:72） 位于package.main.main（main.java:24） 我可以使用任何帮助来帮助解决这个问题，我对Java编程有点陌生。我的完整代码如下：

package package;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.*;

public class Dictionary {
    Collection<String> webster = new ArrayList<String>();
    Iterator<String> iter = webster.iterator();
    File path = null;

    public Dictionary(Collection<String> words) {
        if (words == null) {
            throw new NullPointerException("Error: Collection NULL");
        } else {
            if (!words.isEmpty()) {
                clear();
            }
        }
    }

    public long load(File file) throws FileNotFoundException {
        String filePath = file.getAbsolutePath();
        if (file.getAbsolutePath().equals(null)
                || file.getAbsolutePath().equals("")) {
            throw new FileNotFoundException("Error: No File Found!");
        } else {
            if (file.exists()) {
                Scanner fileScanner = new Scanner(new File(filePath));
                long time = System.nanoTime();
                while (fileScanner.hasNext()) {
                    webster.add(fileScanner.next());
                }
                long time2 = System.nanoTime();
                long duration = time2 - time;
                return duration;
            } else {
                throw new FileNotFoundException("Error: No File Exsists!");
            }
        }
    }

    public boolean contains(String target) {
        if (webster.contains(target)) {
            return true;
        } else {
            return false;
        }
    }

    public void clear() {
        webster.clear();
    }

    public void writer() throws Exception {
        PrintWriter out = new PrintWriter("words.txt");
        while (iter.hasNext()) {
            out.println(iter.next());
        }
        out.close();
    }
}

package；
导入java.io.File；
导入java.io.FileNotFoundException；
导入java.io.PrintWriter；
导入java.util.*；
公共类词典{
集合webster=新的ArrayList（）；
迭代器iter=webster.Iterator（）；
文件路径=空；
公共词典（词汇集）{
if（words==null）{
抛出新的NullPointerException（“错误：集合NULL”）；
}否则{
如果（！words.isEmpty（））{
清除（）；
}
}
}
公共长加载（文件）引发FileNotFoundException{
字符串filePath=file.getAbsolutePath（）；
if（file.getAbsolutePath（）.equals）（null）
||file.getAbsolutePath（）.equals（“”）{
抛出新的FileNotFoundException（“错误：找不到文件！”）；
}否则{
if（file.exists（））{
Scanner fileScanner=新扫描仪（新文件（文件路径））；
长时间=System.nanoTime（）；
while（fileScanner.hasNext（））{
add（fileScanner.next（））；
}
longtime2=System.nanoTime（）；
长持续时间=时间2-时间；
返回时间；
}否则{
抛出新的FileNotFoundException（“错误：不存在文件！”）；
}
}
}
公共布尔包含（字符串目标）{
if（webster.contains（目标））{
返回true；
}否则{
返回false；
}
}
公共空间清除（）{
webster.clear（）；
}
public void writer（）引发异常{
PrintWriter out=新的PrintWriter（“words.txt”）；
while（iter.hasNext（））{
out.println（iter.next（））；
}
out.close（）；
}
}

您现在遇到的问题是，您正在创建迭代器，然后通过加载字典修改列表，然后使用迭代器（现在会引发异常，因为列表是在创建迭代器之后修改的）

您将

迭代器作为实例变量，并在初始化时对其进行实例化。你不想在这里这么做。相反，在使用迭代器的方法中创建该迭代器，例如，去掉实例变量并执行以下操作：

public void writer() throws Exception {
    PrintWriter out = new PrintWriter("words.txt");
    Iterator<String> iter = webster.iterator();
    while (iter.hasNext()) {
        out.println(iter.next());
    }
    out.close();
}

迭代器只是一个临时对象，可以用于在项目集合上进行迭代，它不需要停留。在需要时创建一个，然后在使用完后将其忘记。
在创建
迭代器后但在其完成迭代之前，您正在修改名为
webster
的
集合。这会导致
ConcurrentModificationException

考虑到在进入
writer
之前不需要迭代，只需在那里创建一个本地
迭代器
，它就不会在那里检测修改

PrintWriter out = new PrintWriter("words.txt");
Iterator<String> iter = webster.iterator();
while (iter.hasNext()) {
    out.println(iter.next());
}
out.close();

PrintWriter out=新的PrintWriter（“words.txt”）；
迭代器iter=webster.Iterator（）；
while（iter.hasNext（））{
out.println（iter.next（））；
}
out.close（）；
“package”是一个关键字，因此不是包的有效名称。快速修复：不要使用迭代器。“package”不是真正的包名称，我必须将其切换出去。我知道我不能使用迭代器，但这是一个更大的挑战。@njzk2这不是一个很好的建议，因为它回避了一个一般性的问题，“为什么？迭代器有什么不好的地方吗？”并让读者对迭代器有一种误导性的看法。@JasonC指出，但这是我被告知与迭代器有关的事情，因为我在学习它们之前就已经了解了它们。我知道“foreach”，但它只是我不能在Java类中使用的东西。谢谢你！
PrintWriter out = new PrintWriter("words.txt");
Iterator<String> iter = webster.iterator();
while (iter.hasNext()) {
    out.println(iter.next());
}
out.close();