An ArrayList as used here can contain any type element, including ones
that cannot be cast to String, so that's unsafe . toString can be
called on any type, however, but this would indicate a design flaw,
since you probably expect your AL to contain strings, right ?
So, to make your code robust, you could check the element with
instanceof and then cast it or use 1.5 generics instead.

Definitely use the cast (or let generics do it for you).  Using toString()
would be unforgivably perverse.

   -- chris

I would cast, because it makes it clear that you are expecting a string.
 With a cast it's easier to detect an error, with toString() it isn't.
As to performance I'm not sure there is a big difference. I wouldn't be
surprised if it depended on the implementation. It shouldn't have a
great impact anyway: probably the execution of toUpperCase() takes much
longer

toString  and (String) do quite different things.

You would rarely use (String) today. All it can do is reassure Java
that some Object is indeed ALREADY a String. It cannot change anything
else into a String.  It is not like (int) that can cause a
transformation. Unfortunately, the (cast) syntax has two completely
different meanings, conversion and reassurance.  Today you use
generics instead of most reassurance casting. You no longer need
(String).

toString on the other hand in a worker method that does its best to
display the Object in some reasonable way to make sense to humans.
String.toString just returns the String. All it does is waste time.

So the answer to you question is NEITHER. Use generics. If they
frighten you, use (String). You are reassuring, no converting.

See http://mindprod.com/jgloss/generics.html

Ensure homogenous collections:

    ArrayList<String>  lst = new ArrayList<String>();

Then you don't have to worry about it.