是否从 ArrayList 或 LinkedList 中删除元素，同时在 Java 中使用 for 循环遍历它不好？ 如果是这样，为什么？

Question

I was showing my code to someone and they said that it would cause undefined behavior. Being a Java programmer, that's not something I understand well. In the following code block I am iterating through scenes , which is an ArrayList, and removing elements from it.

for(int i = 0; i < scenes.size() - 1; i++)
    {
        if(!(Double.valueOf(scenes.get(i + 1)) - Double.valueOf(scenes.get(i)) > 10))
        {
            scenes.remove(i + 1);
            i--;
        }
    }

This compiles and doesn't throw an exception at runtime, but I'm still not sure if it's a programming no-no, why it's a programming no-no, and what is the right way to do it. I've heard about using Iterator.remove() and about just creating a whole new List .

Answer 1

In an ArrayList , removing an element from the middle of the list requires you to shift all of the elements with a higher index down by one. This is fine if you do it once (or a small number of times), but inefficient if you do it repeatedly.

You don't really want to use an Iterator for this either, because Iterator.remove() suffers from the same issue.

A better approach to this is to go through the list, moving the elements you want to keep to their new positions; and then just remove the tail of the list at the end:

int dst = 0;
for (int src = 0; src < scenes.size(); ++dst) {
  // You want to keep this element.
  scenes.set(dst, scenes.get(src++));

  // Now walk along the list until you find the element you want to keep.
  while (src < scenes.size()
         && Double.parseDouble(scenes.get(src)) - Double.parseDouble(scenes.get(dst)) <= 10) {
    // Increment the src pointer, so you won't keep the element.
    ++src;
  }
}

// Remove the tail of the list in one go.
scenes.subList(dst, scenes.size()).clear();

(This "shift and clear" approach is what is used by ArrayList.removeIf ; you can't use that directly here because you can't inspect adjacent elements in the list, you only have access to the current element).

---

You can take a similar approach which will also work efficiently with non-random access lists such as LinkedList . You need to avoid repeatedly calling get and set , since these are eg O(size) in the case of LinkedList .

In that case, you would use ListIterator instead of plain indexes:

ListIterator<String> dst = scenes.listIterator();
for (ListIterator<String> src = scenes.listIterator(); src.hasNext();) {
  dst.next();
  String curr = src.next();
  dst.set(curr);

  while (src.hasNext()
         && Double.parseDouble(src.next()) - Double.parseDouble(curr) <= 10) {}
}
scenes.subList(dst.nextIndex(), scenes.size()).clear();

Or something like this. I've not tested it, and ListIterator is always pretty confusing to use.

Answer 2

This is straightforward and will work for either ArrayList or LinkedList:

        Iterator<String> iterator = list.iterator();
        double current = 0;
        double next;
        boolean firstTime = true;
        while (iterator.hasNext()) {
            if (firstTime) {
                current = Double.parseDouble(iterator.next());
                firstTime = false;
            } else {
                next = Double.parseDouble(iterator.next());
                if (next - current > 10) {
                    current = next;
                } else {
                    iterator.remove();
                }
            }
        }