Amarnath schreef:

Read about arrays in the essay on generics.  It is quite complex, and
quite a nuisance, for instance, you cannot do something like

List<State>[] stateList = new List<State>[15];

Only

List<?>[] stateList = new List<?>[15];

or

List<State>[] stateList = new List[15]; (*)

are allowed, the first making it impossible to add anything to the lists
and needing explicit casts when asking for one of the elements of the
list, the second generating an "unchecked" warning.  The reason is that
generics are only in the compiler, and as arrays are also objects, they
can be assigned to Object variables, which leads to all kinds of problems.

See http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf, section 7.3,
but note that there is an error in there, specifically about the line (*).
Also read the section about fun with wildcards, which will probably
solve your problem above: you can write

static <T> void some(Collection<T> c, <? super T> a[]){
 }
........
some(new ArrayList<Float>(), new Number[100]);

H.

I really don't follow your logic there at all. Applying my argument as
above to this example:

The argument "new ArrayList<Float>()", of type ArrayList<Float>, implies
that T is Float. The argument "new Number[100]", of type Number[], is
not assignable to Float[].

Tom Hawtin

Would you want it to compile? If I was writing a function some
(Collection<T> c, T a[]), I would sure want to be able to put the
elements of 'a' into 'c'. But how can I do that if 'a' is an array of
all kinds of Numbers and 'c' can only hold Floats?

If you make it explicit that 'c' and 'a' hold the same kind of things,
then why would you want to start putting something else in there?

Of course, arrays are a different thing than collections; arrays are
more powerful and even a little dangerous. Float[] is a subtype of
Number[], so you can pass in a Float[] where a Number[] is expected
without complaint and everything works just right. That's why some(new
ArrayList<Number>(), new Float[100]) would work, because it is expecting
a Number[] but accepts a Float[]. If you try to put something from 'c'
into 'a' that isn't actually a Float, you'll get a runtime exception.

Some people seem to think that arrays are worse than collections because
of this, if I understand their posts correctly, but I probably don't
because I don't see a problem with it. I wish collections could be as
powerful as arrays! Then I could do away with using real arrays all
together.