Do the List iterators support remove?

The remove method is optional in Iterator and ListIterator. Do the Iterators or ListIterators you get from the JDK lists implement the remove operation? This is not stated in the documentation.

In summary:

• ArrayList.iterator supports remove even though it's not explicitly documented
• LinkedList.iterator supports remove even though it's not explicitly documented
• CopyOnWriteArrayList.iterator does not support remove
• List returned by Collections.unmodifiableList does not support remove

The rule of thumb for the standard classes seems to be: iterators support removal unless there's a good reason not to.

Actually, it's kind of interesting to answer. Java has a history behind Iterators. Let me tell you the history, Then, it'll be clear why things are like this.

Before Iterators java has Enumeration Interface. The methods Enumeration provided are:

1. boolean hasMoreElements()
2. Object nextElement()

Now, java legacy classes like Vector supports Enumeration.

But then, Enumeration got banned in Java while Java started writing its Collection framework in a totally new way i.e. to modernize its Collection framework. Now, in the new Collections java used Iterators. These iterators support the following mehtods:

1. boolean hasNext()
2. E next()
3. default void remove()
4. default void forEachRemaining(Consumer<? super E> action)

I think I've made myself clear to this point.

Now, think about java totally started using Iterators, but there is still a lot of legacy code out there with Enumerations. So, the question is what will happen with those code, as java got updated?

So, java has provided you with a opportunity to use Iterators over Enumerations by default with some legacy classes and those Iterators of those legacy classes are just a wrapper around Enumeration Interface. But these Iterators does not support remove() cause those classes underline Enumeration Interface does not support remove(), that's why. So, when you call remove() on those Iterators, it throws UnsupportedOperationException -> this exception.

I hope till this everything is clear and you've got ur answer. But let me allow to say a little more.

What about those legacy classes those already have been written using Enumerations?

You can solve this problem as java has already done for itself, just provide Iterator wrapper over the Enumeration Interface for new codes you are writing. In this way, you will be writing new codes in new java features and you don't have to change the old code too

The documentation does state that the default implementation of Iterator does not support remove. Whether or not the List#iterator supports remove depends on the List implementation. For example, ListItr defined in the ArrayList implementation supports remove.