Re: No coercion in for-each loop?

From:

Daniel Pitts <newsgroup.spamfilter@virtualinfinity.net>

Newsgroups:

comp.lang.java.programmer

Date:

Sun, 28 Oct 2007 10:24:28 -0700

Message-ID:

<YcydnTBClqxOWLnanZ2dnUVZ_sWdnZ2d@wavecable.com>

Chronic Philharmonic wrote:

"Daniel Pitts" <newsgroup.spamfilter@virtualinfinity.net> wrote in message
news:LbadneoB5dsQJLnanZ2dnUVZ_vKunZ2d@wavecable.com...

Chronic Philharmonic wrote:

"Patricia Shanahan" <pats@acm.org> wrote in message
news:fg18tu$2mo7$1@ihnp4.ucsd.edu...

Chronic Philharmonic wrote:

"Patricia Shanahan" <pats@acm.org> wrote in message
news:fg16ua$2m5f$1@ihnp4.ucsd.edu...

Dave Stallard wrote:

OK, I finally caught up to Java 1.5/6. (Delay had to do with
available tools and my intolerance for Eclipse, but I've reconciled
myself to it now).

Question: Eclipse gives me a compiler error for:

  List list = new ArrayList();
  for (String s : list)
    System.out.println(s);

You are required to make the variable match the base type of the
collection or array in this case Object, but you can do what you like
with each value:

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

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.

The downside of that approach is that if something has gone wrong, and
the List accidentally contains an Integer, there will be no exception
and the program will go on running, possibly with nonsense data.

Fortunately, generics make this approach and the need for typecasting
mostly obsolete.

I would only do it if I really meant that it was OK for any reference
type to be in the List and I just wanted to work with its toString
representation.

I tend to do this when I just want to enumerate the contents of a list
and print a description to System.out or a logger.

If thats the case, you'll get more NPEs than by using String.valueOf(o);

All engineering is a compromise. For some things casting is better. For
others, using o.toString polymorphism is better. In a vacuum, I cannot say
which would be better. It depends on the design, how the collection is being
used, whether you expect nulls in the collection, whether you control the
things you put in the collection, etc. etc. etc. The o.toString pattern is
one of many that I keep in my arsenal. I find it useful at times.

I didn't suggest using casting at all.
String.valueOf(o) is a null-safe way of handling o.toString(). It still
relies on polymorphism, but handles the "null" reference in a safer way.

--
Daniel Pitts' Tech Blog: <http://virtualinfinity.net/wordpress/>