Java 在没有额外线程运行时获取ConcurrentModificationException

如果我在方法中声明迭代器，则以下方法有效。如果我在方法外部声明它，它将导致ConcurrentModificationException。我没有为任何并发操作运行任何其他线程。我不明白为什么在方法内部和外部声明它有区别。我可以在每个方法中声明迭代器，但是我觉得这不是很有效。请告诉我出了什么问题。谢谢

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;
import java.util.Scanner;

public class Linker {

    private static LinkedList<String> list = new LinkedList();

    public static void main(String[] args){
        load("sample.txt");
        find("Sam");
    }

    public static void load(String sourceName){
        try {
            Scanner in = new Scanner(new File(sourceName));
            while (in.hasNextLine()){
                String name = in.nextLine();
                list.add(new String(name));
            }
            in.close();
        }catch (FileNotFoundException e){
            System.out.println("File not found.");
        }
    }

    //static ListIterator<String> iterator = list.listIterator(); //causes ConcurrentModificationException
    public static int find(String name){
        ListIterator<String> iterator = list.listIterator();//this works
        while (iterator.hasNext()){
            String x = iterator.next();
        }
        return -1;
    }
}

导入java.io.File；
导入java.io.FileNotFoundException；
导入java.util.Iterator；
导入java.util.LinkedList；
导入java.util.ListIterator；
导入java.util.Scanner；
公共类链接器{
私有静态LinkedList=新建LinkedList（）；
公共静态void main（字符串[]args）{
加载（“sample.txt”）；
查找（“Sam”）；
}
公共静态无效加载（字符串sourceName）{
试一试{
Scanner in=new Scanner（新文件（sourceName））；
while（在.hasNextLine（）中）{
字符串名称=in.nextLine（）；
添加（新字符串（名称））；
}
in.close（）；
}catch（filenotfounde异常）{
System.out.println（“未找到文件”）；
}
}
//静态ListIterator迭代器=list.ListIterator（）；//导致ConcurrentModificationException
公共静态整型查找（字符串名称）{
ListIterator iterator=list.ListIterator（）；//这很有效
while（iterator.hasNext（））{
字符串x=迭代器.next（）；
}
返回-1；
}
}

如果在两次调用此方法之间修改了Direct列表，则可能会出现问题

在方法中获得迭代器后，每次调用该方法时都将使用“新鲜”迭代器

---

当迭代器是在方法之外获得的，那么（在第二次调用期间，在其他人修改了列表之后），它只会注意到“嘿，其他人对这个列表做了一些事情，我不能确定我是否处于一致状态”，并使用

ConcurrentModificationException

退出。当在两次调用此方法之间修改

Direct

列表时，可能会出现问题

在方法中获得迭代器后，每次调用该方法时都将使用“新鲜”迭代器

---

当迭代器是在方法之外获得的，那么（在第二次调用期间，在其他人修改了列表之后），它只会注意到“嘿，其他人对这个列表做了一些事情，我不能确定我是否处于一致状态”，并使用

ConcurrentModificationException

退出。当在两次调用此方法之间修改

Direct

列表时，可能会出现问题

在方法中获得迭代器后，每次调用该方法时都将使用“新鲜”迭代器

---

当迭代器是在方法之外获得的，那么（在第二次调用期间，在其他人修改了列表之后），它只会注意到“嘿，其他人对这个列表做了一些事情，我不能确定我是否处于一致状态”，并使用

ConcurrentModificationException

退出。当在两次调用此方法之间修改

Direct

列表时，可能会出现问题

在方法中获得迭代器后，每次调用该方法时都将使用“新鲜”迭代器

---

当迭代器是在方法之外获得的，那么（在第二次调用期间，在其他人修改了列表之后），它只会注意到“嘿，其他人对这个列表做了一些事情，我不能确定我是否处于一致状态”，并使用

ConcurrentModificationException退出

应尽快使用迭代器。因此，在方法中创建它是绝对有意义的，而不是在其他地方

---

但是，将其创建为实例字段确实没有意义。我假设您在其他方法中添加和删除值。每次这样做时，您都会修改列表，因此下一次访问迭代器时将抛出

ConcurrentModificationException

迭代器应尽快使用。因此，在方法中创建它是绝对有意义的，而不是在其他地方

---

但是，将其创建为实例字段确实没有意义。我假设您在其他方法中添加和删除值。每次这样做时，您都会修改列表，因此下一次访问迭代器时将抛出

ConcurrentModificationException

迭代器应尽快使用。因此，在方法中创建它是绝对有意义的，而不是在其他地方

---

但是，将其创建为实例字段确实没有意义。我假设您在其他方法中添加和删除值。每次这样做时，您都会修改列表，因此下一次访问迭代器时将抛出

ConcurrentModificationException

迭代器应尽快使用。因此，在方法中创建它是绝对有意义的，而不是在其他地方

---

但是，将其创建为实例字段确实没有意义。我假设您在其他方法中添加和删除值。每次修改列表时，您都会修改该列表，因此下一次访问迭代器时将抛出

ConcurrentModificationException

，正如@Marco13所指出的，问题是在调用该方法之间修改了

Direct

。大多数收藏的文档与以下内容类似：

此类的迭代器和listIterator返回的迭代器 方法是快速失败的：如果列表在任何时候进行了结构修改 创建迭代器后的时间，以任何方式，除了通过 迭代器自己的remove或add方法，迭代器将抛出 ConcurrentModificationException。因此,面对同时发生的冲突, 修改

private List<String> list = new ArrayList<>();
private ListIterator<String> itr = list.listIterator(); //at this point mod count is 0

public static void load(String sourceName){
        list.add("Foo");// increment mod count by 1
}