Re: what is the initial value of arrays of object
Eric Sosman wrote:
George wrote:
I am using java 1.5.
class A{
A(){
}
A(int){
}
...
}
A[] a=new A[10];
For such an array, what is the initial value for each a[0]...a[9]?
null, null constructor, or something else?
They are all null. (I don't know what you mean by "null
constructor;" it's a term I've never seen before.)
Probably the no-argument constructor.
It occurs to me that it might be somewhat-useful if Java added some
syntax (which wouldn't break source compatibility, I don't think) as a
shortcut for constructing multidimensional arrays and for initializing
arrays with all-identical elements other than zero, null, or false.
Proposed:
new X[x][y] -> an array of y X[] references, each pointing to a distinct
new X[x] instead of to null.
new X[x]() -> an array of x X references, each pointing to a distinct
new X().
new prim[x](value) -> an array of the appropriate primitive type, each
cell assigned the specified value (e.g. new int[10](1) would produce an
array of ten ints with the value 1 instead of the normal 0; new int[10]
would still produce an array of ten zeros of course).
new X[x](arg1, arg2...) -> an array of x X references, each pointing to
a distinct new X(arg1, arg2...)
new X[x][y](arg) -> an array of y x[] references, each pointing to a
distinct new X[x](arg) instead of to null; essentially, a
two-dimensional x by y array of x*y new Xs all constructed with the same
arg.
The usual rules would apply vis-a-vis overload resolution of
constructors, narrowing conversions, and so forth; indeed, all of the
above (and their obvious generalizations for more dimensions) would just
be short forms for
foo = argument_expression;
X[] temp = new X[x];
for (int i = 0; i < x; ++i) {
temp[i] = new X(foo);
}
and suchlike. (Argument expression assigned to a temporary so if it has
side effects, they only occur once.)
The obvious optimizations would apply when the array is of primitives or
strings and the construction argument value is known at compile time,
and its evaluation known to lack side effects. Then
new int[10](1)
is simply short for the array literal
{1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
though it is perhaps a bit more readable (it's shorter, and the number
of 1s can be read off at a glance).
This sort of thing might not be used enough to justify the effort,
though, save perhaps for the not-infrequent case of initializing an
array of arrays with equal-sized subarrays (that is, making rectangular
two-dimensional arrays, or analogous structures in more dimensions).