In java.util.Arrays there is a private static class called "ArrayList" defined. It is only referred from Arrays.asList method.
What is the benifit of doing this? Why is java.util.ArrayList not referred instead?
Code below:
/**
* @serial include
*/
private static class ArrayList<E> extends AbstractList<E>
implements RandomAccess, java.io.Serializable
Despite the fact that the private static ArrayList class shares the same name as java.util.ArrayList, they behave differently by design. Given that, there's no reason that the implementations should be one and the same.
Arrays#asList()returns a fixed-size list backed by the specified array. (Changes to the returned list "write through" to the array.) This method acts as bridge between array-based and collection-based APIs.
Arrays.asList() returns a list which cannot be resized. It's right there in the documentation, if you read it ;-)
asList(a).add(x) will throw an exception (because the returned list is a fixed size and a new item cannot be added) and asList(a).set(n,x) will modify the original array (as per "write through to the array"). Note that asList is typed to return the List interface (of which the utils.ArrayList and the private ArrayList classes implement).What is the benefit of doing this? Why is
java.util.ArrayListnot referred instead?
One reason is that the actual implementation class is not a public API detail. Doing this means that they can change the implementation class it in the future ... without any risk of breaking customer code.
Another reason for doing this is that this private class implements some operations differently to ArrayList. In particular operations that would involve changing the size of the list need to be implemented to throw an exception ... in order to conform to the behavior specified in the javadocs for the Arrays.asList(...) method.
In reality, the list returned by Arrays.asList(...) is a wrapper for the original array, and not a full-function, free-standing list. This is has advantages and disadvantages:
On the down-side, certain operations don't work; e.g. adding and removing elements.
On the up-side, creating a wrapper is a lot cheaper than creating a first-class list out of an array. (The latter entails copying the array contents into the list ... and that will be expensive for a large array.)
Also, there is the issue that changes to the original array are visible via the wrapper (and vice versa) ... which can be useful if that is what you need.
You asked this in a comment:
a) Why return non resizable list?
Because returning a regular resizable list entails copying the array contents at some point... which is expensive. (And if the implementation deferred the copying until a size-changing operation was performed, the relationship between the original array and the list would be really difficult to understand. Think about it ...)
b) Why not use
Collections.unmodifiableListand pass thejava.util.ArrayListobject?
That doesn't achieve anything. You still have to copy the array contents to the ArrayList. The whole point of this "strange" behavioral spec is to avoid the need to copy.
