26

I know that similar questions have been asked several times and they were nicely answered but... they were about zero length array of 1 dimension like:

int[] array = new int[0];

Seems that there is a purpose for such arrays in case when null should not / cannot be used. But why Java allows to create things like that:

int[][][] multiDims = new int[5][0][9];

Of course like in simple 1D case we get nothing from such array if we try to iterate or something and I am asking only because it looks extremely nasty for me. :-) How much memory is allocated for such a pointless creature?

Improve this question
4
  • Is your question why is it allowed or how much memory is allocated? Commented Jan 14, 2016 at 13:09
  • 9
    Developers write pointless code all the time and it is not possible to detect every pointless combination a developer can come up with. Commented Jan 14, 2016 at 13:21
  • 3
    It would appear you can also compile new int[-1] successfully ideone (it obviously fails at runtime, however). This looks like the sort of error that tools like Google's error-prone might set out to catch (although it looks like it doesn't currently, maybe because it is just too silly). Commented Jan 14, 2016 at 13:41
  • If you disallowed this, it force special case handling on the programmer for cases that naturally work under the current specification. Commented Jan 15, 2016 at 10:01

3 Answers 3

Reset to default
31

As for why Java allows this - from the point of view of the language (not the concepts you're trying to express with it), why should it specifically disallow this? If you allow a zero-length array of any type, why specifically disallow a zero-length array of int[9]? Disallowing it would necessitate more compiler checks to enforce a rule that's basically useless, because even without the rule the behavior is well defined.

Bottom line, compiler checks are not here to ensure your program makes sense. They're here only to check it's unambiguous.

Edited to add:

As pointed out in a comments, such check is not even really possible, since array length is not part of the type information and can be given at run time. So, apart of a "special case" when there's int[0] directly in the source code, compiler doesn't even have any means to know whether it is a zero-length array.

Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

It's a zero-length array of int[]. The size is not part of the type in Java.
It should also be noted that this is the special case of a special case. The dimension don’t need to be constants in Java, hence, there is always a way to pass exactly these numbers to an array creation expression without the compiler being able to predict that. And with dynamic values, this combination may make sense in context.
@Holger good point, I edited the answer. That illustrates nicely why the check is not only impractical but also often impossible.
24

This will create 6 objects - 5 empty arrays and an array containing these arrays.

Why is it allowed? For the same reason as in case of 1-dimensional arrays. If you create an array like this:

int[][][] multiDims = new int[p][q][r];

where each p, q and r can be sometimes 0, handling these special cases would be very difficult. Instead you get a legitimate object which can be used in a loop (a very short loop - a one that ends immediately, but without errors).

Improve this answer

2 Comments

Your point avoid avoiding the need for special cases is a good one. The maintainers of many language standards seem to take the attitude that if executing some construct in a specific case would serve no useful purpose there's no reason to support it, even if it would allow a useful generalization, so I like seeing examples of places where allowing such generalizations is useful. An example of a language which annoyingly disallows such usage is C99; it allows arrays to be declared with a size computed at runtime, but declaring a zero-sized array invokes Undefined Behavior even if code...
...never makes any attempt to actually access it (e.g. all access to the array is in a for loop whose body never executes if the size is zero), and Undefined Behavior in C is worse than anything which exists in Java, since it allows compilers to throw all notions of time and causality out the window.
8

The [5] actually does something useful: The outermost array will have five element arrays with length 0.

But you're right about the [9]. It doesn't do anything: Since all of the five intermediate arrays will be empty no array of length 9 will be created. Any integer could be put there to exactly the same effect.

The language could have been designed so that if there was one level of nested array with dimension set to literal 0, then all subsequent levels would have to be set to literal 0 as well. But that would create yet another a special case in the specification and implementation and the benefit would be very small.

Improve this answer

7 Comments

The [9] might actually serve a purpose. Maybe not a functional one, but a semantic one: It means the third dimension of the array should be of length 9, which might be useful if you plan to add elements so that the second dimension stops being empty.
@Darkhogg It's not possible to resize a Java array after instantiation
@Max so? You can swap the empty arrays for non-empty ones.
@Darkhogg If you replace one of the top-level arrays with another array, then it doesn't matter what the original dimensions of the replaced array are. See ideone.com/cHvI84 for an example
@Darkhogg Although I just realized that I may have misinterpreted your original comment. I agree there are cases in which it makes more sense to do it like this for semantic clarity, regardless of its functional aspects
|

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.