Hi Jaikiran!
The first part (the documentation clarification) was requested some time
ago [1], so it may be eventually fixed.
[1] https://bugs.openjdk.java.net/browse/JDK-7033681
With respect to the second part (throwing UOE from remove(Object)), I
agree with you that it would be more consistent to always throw it,
regardless of the presence of the searched item.
However, it would introduce a change of behavior, so I think it's
unlikely to happen.
It may make sense to update the documentation for all the
structurally-modifying methods of Collection/List (remove(Object),
retainAll, removeAll, clear) in the same way it was done for
List.removeIf() here [2].
[2] https://bugs.openjdk.java.net/browse/JDK-8023339
With kind regards,
Ivan
On 8/14/18 10:58 PM, Jaikiran Pai wrote:
Consider the following code:
import java.util.Arrays;
import java.util.List;
public class ArraysAsListTest {
public static void main(final String[] args) throws Exception {
final List<String> someList = Arrays.asList(new String[] {"a"});
System.out.println("Removed? " + someList.remove("a"));
}
}
It uses Arrays.asList to create a java.util.List and then calls a
list.remove(...) on it. This currently runs intothe following exception:
Exception in thread "main" java.lang.UnsupportedOperationException: remove
at java.base/java.util.Iterator.remove(Iterator.java:102)
at
java.base/java.util.AbstractCollection.remove(AbstractCollection.java:299)
at ArraysAsListTest.main(ArraysAsListTest.java:8)
The javadoc of Arrays.asList[1] states the following:
"Returns a fixed-size list backed by the specified array. (Changes to
the returned list "write through" to the array.)..."
and has no other mention of how it's supposed to behave with "write"
operations. Given that the javadoc states that the returned list is
"write through", would that mean a "add/removal" is allowed? Probably
not, because it does say it's a fixed size list.So the size altering,
write operations (like add(), remove()) aren't allowed, but that isn't
clear from the javadoc. So should the javadoc be updated to clarify the
semantics of what changes are "write through" and what changes are not
supported?
Furthermore, the UnsupportedOperationException isn't always thrown from
such a returned list. Consider this minor modification to the above code:
final List<String> someList = Arrays.asList(new String[] {"a"});
System.out.println("Removed? " + someList.remove("b"));
I add "a" and remove "b". This now runs fine without exceptions and
prints "Removed? false". Should the implementation just throw the
UnsupportedOperationException irrespective of whether or not the element
is contained insuch a returned list? If not, should that be made clear
in the javadoc (maybe same for addoperations)?
[1]
https://docs.oracle.com/javase/10/docs/api/java/util/Arrays.html#asList(T...)
-Jaikiran
--
With kind regards,
Ivan Gerasimov
