When is a generic array absolutely necessary -- a case

Question

This Q is to look for a sample case where a generic array is absolutely necessary.

Generics and arrays "don't mix well".

Is there a case where a generic ArrayList won't do-- a generic array has no substitute and has to be used.

Effective Java leaves a door open for generic arrays saying that there may be cases where a generic array is necessary.

I've been using ArrayList without any shortcomings and can't think of a case like this.

TIA.

Note: i've seen these:

• How to create a generic array in Java?
• Generic List and Generic Array
• Generic array creation error
• Java generics and Array's

Along with some other discussions.

Answer 1

Some points:

• If you have some "legacy" library then you're bound to the types that they use. This could be arrays.

• If you handle native code then arrays will be a more natural way to exchange data with the native code.

• If you access binary data (e.g. sound files or similar) then using an array can help.

• If you handle big amount of binary data then an array could be more efficient.

So there are many reasons why an array could be helpful (especially with primitive types).

If you only handle objects then it is most times easier to use a List.

Answer 2

I would say that Bloch meant convenient instead of necessary, arrays are simpler structures, easier to handle.

As a data structure, from a functionalities point of view, ArrayList are interchangeable with array.

Arrays are obviously more lean memory-wise but require additional effort to get some basic functionalities (i.e. manual array resizing when the original array is not big enough to hold a new element) but other functions are already provided by the runtime (Arrays class).

ArrayLists are backed by actual Object arrays so there isn't much difference performance wise, for common operations like searching and sorting (when using the same algorithm).

Answer 3

Some loose thoughts:

array is a basic data type that's necessary in any imperative language (maybe in a disguised form). Without array, how can we implement ArrayList?:)

However, we could have disguised array as a "normal" type. For exmple, we could introduce a intrinsic lang.lang.Array<E> type that does array things, and eliminate the current array type in Java. (Ignoring primitive arrays, that's another topic). Everything will work out fine.

Yet, we don't have the luxury to "improve" and "clean" the language in a way that breaks backward compatibility.

Before the introduction of generics, array can be seen as a poor man's generics. We couldn't express ArrayList<String>, but we could do String[]. That is why a lot of old APIs return an array, instead of some collection type, because array was more type-safe. array is even co-variant ... sort of.

After the introduction of generics, the use cases for array become far fewer. Usually, you should avoid using array in a public API. (Of course, except for var-arg foo(Bar...) which is array under the hood)

But in the implementation code, we still need array, it's the basic data structure to build more complex data structures. For that purpose ArrayList is obviously more bloated in many cases.

Now, the question is, to implement something like ArrayList<E>, should we use a E[], or Object[] internally? Due to erasure, E[] is more troublesome - as the saying goes "generics and arrays don't mix well". So forget it, just use Object[] and do the cast when necessary.

Answer 4

An ArrayList requires a small amount of extra memory as compared to an array. This is obviously true as an ArrayList is implemented as a wrapper around an array. By my rough estimation, an ArrayList will consume an additional 16 bytes.

Under normal circumstances, this is nothing to worry about. But if you're creating a very large number of arrays (millions/billions), it could potentially make a difference.

There is also the case of primitive arrays. ArrayList is constrained by the rules for collections, so it cannot store primitive elements, only the corresponding object wrapper. So for example, byte[] consumes 1 byte per element, but ArrayList<Byte> consumes 4 bytes per element. This can make a difference if your arrays are potentially very large.

Answer 5

Generally, the ArrayList is considered to be more favourable than arrays. It provides the same functionality, while integrating better, especially with other types from the Java Collection API.

Therefore, the use of arrays could result out of special requirements. On the one hand, one may want to use a library (or other 3rd party code) which requires arrays.

One the other hand, arrays still perform better than an ArrayList. I created a Gist which compares the use of an ArrayList<Integer> to an int[]. (Note, that you can't use primitives with ArrayLists.) The average results for creating 1.000.000 random elements and finding their maximum on my machine:

Test case CREATE_ARRAY average time: 25.93 ms
Test case CREATE_ARRAY_LIST average time: 44.06 ms
Test case MAX_OVER_ARRAY average time: 1.44 ms
Test case MAX_OVER_ARRAY_LIST average time: 5.86 ms

So, we're roundabout 4 times slower with an ArrayList. Yet, in normal use cases, this can safely be considered as micro optimization. Most use cases demand code quality over such performance improvements.

Answer 6

[...] saying that there may be cases where a generic array is necessary.

It seems like Joshua Bloch simply wanted to be safe allowing a possibility even if he don't know one.

Why would an author mention such a point without an example if he knows there is one ?

Assuming ArrayList store it values itself in an array and only provides useful method so that you don't have to re-write everything, I would be highly suprised to face a case where you can't achieve something with an ArrayList but can achieve with an array.

The data structure itself is the same, remember Arrays.asList and ArrayList.toArray

Answer 7

Generics is for not needing to rewrite code when using different objects in an array, or when holding child instances and not being able to cast in a loop for example. you let classes and interfaces be parameters in other classes.

oracle tutorials

Elimination of casts. The following code snippet without generics requires casting:

List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0);

When re-written to use generics, the code does not require casting:

List<String> list = new ArrayList<String>();
list.add("hello");
String s = list.get(0);   // no cast

Answer 8

I thought of a couple things immediately when I read the question.

One: If you're using Java Micro Edition, you may not have ArrayList available to you. This kind of thing is fairly common if you ever work on legacy code. Writing in .Net 1.1 or 2.0 feels a lot like cutting your arms off compared to 4.0 and later(in my opinion). Java Micro Edition is similar - If you're used to Java 6+ then J2ME feels really restrictive. This question discusses it a bit, but I think I'd go with a regular array than use a vector(which according to that thread is synchronized...I haven't delved deeper than that).

Two: If you're on an embedded system and need to have tight control over the size of the array. Other answers touched on this a bit. IIrc the default functionality of ArrayList is to double in size when it resizes, but I'm having trouble finding an exact quote on that. On embedded systems with very limited memory, it wouldn't surprise me if such a resize tried to allocate more than all the memory in the system(eg your array takes up 75% of all system memory, on a resize it'll try to take up 150% of the memory). If you use an array and manually control all resizes, then this becomes a non-issue.