What is the motivation of retrieving the length of an array using a public instance variable, instead of calling a method? [duplicate]

Question

This question already has answers here:

Where is array's length property defined? (7 answers)

Closed 9 years ago.

Since most other classes seem to let the developer retrieve the length or size of its content by calling a method, usually length() or size(), how come the length of an array is retrieved by reading the instance variable length? It just seems inconsistent to me, especially since a String object is immutable as well and still uses a length() method.

Answer 1

It is inconsistent. I suppose the actual reason for the distinction can only be found in the early history of Java language development. Perhaps it was for what seemed at the time to be performance reasons. I suspect that if Java were being (re)designed from scratch today, the length field would disappear and instead there would be a java.lang.Array class^* (similar to java.lang.Enum) from which all arrays would derive and which would include a length() method inherited by all arrays.

Actually, the lack of an Array class (in the above sense) may indicate why there's a length attribute: arrays are more "built in" to the language than, say, the collection classes (which are part of a class library).

^* Java does have java.lang.reflect.Array, but that does something completely different from what I'm talking about.

Answer 2

Most of the collections have dynamic sizes, so they need a method to verify the length/size in that specific time. An array has a fixed length, so it doesn't need to be recalculated all the time.

Answer 3

An array is of fixed size - it will never change. As such, you don't need the overhead of a method.

Answer 4

The reason why is that the JLS says so:

The members of an array type are all of the following:

• The public final field length, which contains the number of components of the array. length may be positive or zero.

Regarding the underlying motivation: only the people who created the language could answer...

Interestingly, Oak, which is the language at the origin of Java, already had that notion. If you read its specifications, you will see that:

The length of any array can be found by using .length

So the best guess here is that it is the result of a decision made by a few guys more than 20 years ago.

Answer 5

A method is executed every time it's called. Optimization exists, such as cache etc.. but the point is that an array never gets its size changed.

Thus, what could better fit the case than a "final" (not sure about the implementation under the hood but same concept) instance's field?

java.util.Collection describes some classes wrapping arrays like ArrayList, HashSet etc.. In their case, size is altered since the concept of collection is to have an extensible array. Thus, the size must be calculated thanks to a method (size()), not a field in this case.