Thanks, Timo.

   static <T> void a(T[] e, Collection<T> c) {
         e[0] = c.iterator().next();
    }

   static <T> void b(T[] e, Collection<T> c) {
          e[0] = (T)((ArrayList)c).get(0);
   }

Can u tell, why a passed comile, but b has  unchecked or unsafe
operations ?
I meant in b, compiler should have known that all elements in array or
in collection,
are of type T.

Hi Timo,

I think, Johns example is not so good (because his cast pointed you in a
wrong direction). I think, Johns idea is correct, that your example (the
other way round) would suffer the same problem:

Imagine what would happen if this would compile, and your method did
something:

  static <T> void method(T[] e, Collection<T> c) {
    int i=0;
    for (T t : c) {
      e[i++]=t;
    }
  }

  String[] sa = new String[10];
  Collection<Object> co = new ArrayList<Object>();
  co.add(new Long(0));
  method(sa, co);
  String s = sa[0]; // obviously an error

The point is (what Mike said): 'Arrays "know" [at runtime] what type
they should contain; generics do not.'

I think this asymmetry between Arrays and generic Collections is a great
design flaw. (Although I am aware that solving this is not easy and
suffers other problems... one main problem is that a String[] can be
assigned to an Object[]-variable: A String[] does not have all abilities
of an Object[] (for example the ability to insert a Long), so it sould
not be assignable!)

Ciao,
Ingo

There are two different idea fighting it out here.

1.  List<Object> is a list that can contain any sort of object.

2. List<?> is a reference that can refer to any list, regardless of what
sort of object that list consists of.

They are quite different things.  The fact that

   Object[]

fulfills both for arrays serves to confuse things, but

   new Object[12]

is the first idea, and

   Object[] ref = new String[12]

is the second idea.