未调用相关变量却有元素被添加至LinkedList的问题排查

Hey there, let's break down why you're seeing unexpected elements pop up in your Queue<ArrayList<String>> path even when you don't explicitly call methods to add to it. Based on the code snippets you shared, here are the most likely culprits and fixes:

1. You're Copying References, Not Actual Lists #

The biggest red flag here is how you're copying elements from path to tempArr:

ArrayList<ArrayList<String>> tempArr = new ArrayList<>();
for(ArrayList<String> a : path){
    tempArr.add(a);
}

In Java, ArrayList is a reference type—when you add a to tempArr, you're not creating a brand new list. You're just copying a pointer to the same underlying list object that's already in path.

So if later in your code you modify any list inside tempArr (like adding a string to tempArr.get(0)), that change will directly show up in the corresponding list in path. It looks like elements are "magically" appearing in path, but it's just the same list being modified through a different reference.

Fix for This: #

Make a deep copy of each list when you copy to tempArr:

ArrayList<ArrayList<String>> tempArr = new ArrayList<>();
for(ArrayList<String> a : path){
    // Create a new ArrayList with all elements from the original list
    tempArr.add(new ArrayList<>(a));
}

This way, tempArr holds entirely separate lists from path, so modifications to one won't affect the other.

2. Accidental Reference Sharing with Other Variables #

You mentioned declaring ArrayList<String> tempArrNew = null; and having other lists like shortestPath in your method. If at any point you assign one of these method-local lists to path (or to a list that's already in path), you'll end up with unintended links.

For example, if you have code like this later in your loop:

tempArrNew = shortestPath;
path.add(tempArrNew); // Oops—this adds your method's list to the instance-level path

Or if you modify shortestPath after it's been added to path, those changes will show up in path automatically.

Fix for This: #

Do a full audit of all places where you interact with path, tempArrNew, shortestPath, and tempArr. Add debug logs at key points to print the size of path and the contents of lists, so you can trace exactly when elements get added. For example:

// Log before and after critical code blocks
System.out.println("Path size before tempArr copy: " + path.size());
// ... your tempArr copy code ...
System.out.println("Path size after tempArr copy: " + path.size());

3. Concurrent Modification in Multi-Threaded Code #

If this code runs in a multi-threaded environment, another thread might be modifying the instance variable path while your loop is running. LinkedList isn't thread-safe, so unsynchronized access across threads can lead to weird, unexpected behavior—like elements appearing out of nowhere.

Fix for This: #

Switch to a thread-safe queue implementation like ConcurrentLinkedQueue for your path variable:

Queue<ArrayList<String>> path = new ConcurrentLinkedQueue<>();

Or wrap all operations that access or modify path in a synchronized block to ensure only one thread can interact with it at a time:

synchronized(this) {
    // Your code that reads/writes to path goes here
}

内容的提问来源于stack exchange，提问作者Mitchell Kerr