Excuse the self-followup, here.

You cannot completely avoid casts, but you can use casts that are
verifiably correct.  Consider:

 String[] args = new String[0]; // No element to query.

 Class<? extends String[]> c = args.getClass ();
 Class<?> elt = c.getComponentType ();

We know from reading the code that elt is really String.class (which
is of type Class<String>), but the depicted bounds are the most strict
bounds available without casts through the Reflection API.  It gets
better.

 Object newArr = java.lang.reflect.Array.newInstance (elt, 8);

newArr is actually a String[], which we can verify by inspection or by
reflection, and you can cast the object to String[] and use it as one
from there on.

The same is true if we replace String throughout with T, which is a
generic type in this scope.

Part of the problem is that there is no type relationship between
String[] and String that can be expressed using generics type
constraints.

For completeness, here is a tested class which, given an array,
creates another array of the same element type and returns it as a T[]
rather than an Object[].

package com.unreasonent;

import java.lang.reflect.Array;

public class Arrays {
 private Arrays () {
   assert (false);
 }

 public static <T> Class<?> getElementClass (T[] array) {
   return array.getClass ().getComponentType ();
 }

 @SuppressWarnings("unchecked")
 public static <T> T[] createArrayLike (T[] original, int length) {
   Class<?> eltType = getElementClass (original);
   return (T[]) Array.newInstance (eltType, length);
 }
}

-o

On Wed, 2 Jan 2008 01:44:48 -0800 (PST), Owen Jacobson
<angrybaldguy@gmail.com> wrote, quoted or indirectly quoted someone
who said :

You got it.  You can see how well I have done
http://mindprod.com/products.html#SHELLSORT
http://mindprod.com/products.html#RADIXSORT
http://mindprod.com/products.html#HEAPSORT
http://mindprod.com/products.html#QUICKSORT

The code WORKS fine, it just bugs me to have a warning.  I could use
annotations to suppress it, but that is cheating.  It seems to there
should be a way to do this cleanly.  

When I was a kid I used to sell mimeographed cheat sheets for five
cents each to my fellow students.  I created mindless algorithms to
solve various sorts of problems.  The teachers would plug them for me.
I composed them for math, physics, chemistry, genetics...  

I would, as an adult, like to cook one up for generics.  But first I
have to properly understand it myself. It is still pretty foggy,
despite quite a bit of reading.

On Wed, 2 Jan 2008 01:44:48 -0800 (PST), Owen Jacobson
<angrybaldguy@gmail.com> wrote, quoted or indirectly quoted someone
who said :

I thought of that, but have not yet tried it.  I have many messy
little projects on my plate all half done.

It smells a bit too strongly of kludge.  I can get the object that
way.  But can I get the reference?