It is worth noting though that Eclipse uses its own compiler not
a standard JDK compiler.

Arne

Yes, "hissy".

We don't expect them to be imprecise.  We expect them to do things
automatically for us, rather than make us do them.  That's what
compilers are for.  In this case, the compiler has all the knowledge it
needs right there in the code to insert the cast *itself*.   It has the
declaration of the iteration variable as String.  It can see that the
list variable is a raw-type list:

  for (String s : (List<String>)l) ...

It's the same mentality that forces us to write:

  Foo f = (Foo)..expression..

It sees that f is a Foo.  It doesn't know that expression is a Foo.  So
it can see that a typecast is needed, and even tells you so.  But it
makes YOU type it in.  What sense is there in that?   It should at most
be a compiler warning, not an error.   This may seem small, but iterated
millions of times over one's life span, it becomes very annoying.  It's
one of the things that's making people rail against "strong typing", and
driving them to scripting languages like Ruby.  Strong typing is good;
unnecessary typing (pun intended) is not.

What's more, it's not even consistent, as I showed in the other snippet.
  It's still possible to generate run-time class cast exceptions

No, you're missing something.  This rule means that in order to use the
for-each loop in a useful way, you have to buy into Java generics!
That's no good.  So the one thing they did to make your life easier, and
should have done from the beginning - obviating the need for Iterator
everywhere - they f.cked up.

By the way, and I don't mean to wound your feelings here, but in C# this
 works fine.  Oh, and they also give you '[]' for array fetching like a
NORMAL programming language.

Don't get me wrong. I still use Java for its compatibility on Windows
and Linux, and for its now-quite-respectable speed relative to C++.  I
used it back when no one else in my group used it, and I will continue
to use it.  But with respect to Java's progress as a *programming
language* I am bitterly disappointed.

  Dave

Or, you could say

for (Object o : list){
  String s = o.toString();
  ...
}

since all objects support toString, including um, Strings. Of course, this
only works for Strings, but Strings are pretty common in the wild.

I don't see that you are saying this in the above code. What you are
saying is "As far as I recall, 'ar' is actually a List<String> so this
should work a treat" - much as if you had written
Object o = ...;
String text = o;

The compiler doesn't accept the latter, why should it accept the
former? Shouldn't it /require/ you to write
List<String> list = (List<String>) ar;
in the same way that it requires
String text = (String) o;
?

(Not that the cast would do you any good though, since
      List ar = new ArrayList<Integer>();
      ar.add(1);
      List<String> list = (List<String>) ar;
      for (String s : list)
           System.out.println(s);

doesn't actually barf on the cast, but on the for statement. This
might be the reason I suppose - Java doesn't require the explicit cast
because it's unable to verify it anyway. This doesn't really improve
the situation in my eyes. But we may just be rehashing old complaints
about the generics system here.)

Cheers,
    Bent D

Actually, there is a difference between declaring things with List<?>,
List, and List<Object>
Where the generic type appears, they all look like Objects, but

This whole thread is probably best answered by Sun's Generics Tutorial
on how to deal with legacy code.
<http://java.sun.com/docs/books/tutorial/extra/generics/legacy.html>

Hope this helps,
Daniel.