>> Would be the correct syntax? Or do primitives get promoted to objects
>> somehow?
>
> Yes, the compiler (since 1.5) automatically converts the original expression
> into something similar to what you have. It's called "autoboxing" and is a
> bloody stupid idea.
What's stupid in that idea? Can you argue please?
> The compiler actually generates code to call the static valueOf(<primitive>)
> method rather than using an explicit constructor, which can in some cases make
> use of cached lists of pre-allocated instances. E.g. the line stuff[4] = 123
> will generate a call to the (new in 1.5) method Integer.valueOf(int), which
> (from the 1.5 code, not the spec) will in fact use the cache since 123 is in
> the cached range [-128, 127].
That's from spec (JLS 3rd ed.):
"5.1.7 Boxing Conversion
(...)
If the value p being boxed is true, false, a byte, a char in the range
\u0000 to \u007f, or an int or short number between -128 and 127, then
let r1 and r2 be the results of any two boxing conversions of p. It is
always the case that r1 == r2."
piotr
Bart Cremers - 24 Jul 2006 09:36 GMT
Piotr Kobzda schreef:
> >> Would be the correct syntax? Or do primitives get promoted to objects
> >> somehow?
[quoted text clipped - 4 lines]
>
> What's stupid in that idea? Can you argue please?
I'm not totally against autoboxing, but it should be used with great
care. Specially when used in conjunction with generics. Take following
code:
List<Integer> carefull = new ArrayList<Integer>();
carefull.add(1);
carefull.add(43);
carefull.add(227);
carefull.remove(43);
System.out.println(carefull.size());
This compiles fine and the output seems pretty straightforward, but
what you get is this:
Exception in thread "main" java.lang.IndexOutOfBoundsException:
Index: 43, Size: 3
on the remove line.
Regards,
Bart
Chris Uppal - 25 Jul 2006 09:29 GMT
> > Yes, the compiler (since 1.5) automatically converts the original
> > expression into something similar to what you have. It's called
> > "autoboxing" and is a bloody stupid idea.
>
> What's stupid in that idea? Can you argue please?
The basic problem is that it makes it look as if one thing is happening, when
in fact something completely different is happening. That is just bad language
design, for both beginners and experts. /Especially/ when it doesn't add to
the expressive power of the language.
(Of course the /real/ problem here, is the use of non-object primitive types at
all -- at least as the "normal" way to express numeric values -- but that's a
different debate...)
It (autoboxing, or indeed any other sleight-of-hand[*] in the compiler) can
cause the unwary to introduce performance problems, or semantic problems,
without realising it. E.g, some time ago, there was a person posting about
memory problems here -- it was only after some considerable amount of
speculation and debate that we realised he was holding around a million
"floats" in an ArrayList (or something like that). Since he didn't realise
that his -- otherwise perfectly reasonable -- Java code wasn't doing what he
thought it did, he didn't initially mention how he was storing all those
values. That only emerged later.
Autoboxing causes (yet more) ugly little glitches with generics too -- but I
can't remember exactly what and it's too hot to go searching ;-)
> That's from spec (JLS 3rd ed.):
Aha! Thank you for the correction.
-- chris
[*] "Sleight-of-hand" as in the shell-and-bean game, or its variants, where the
unwary punter is induced to bet, unwisely, that the bean is under the shell it
/seemed/ to be placed under....