Greetings Earthlings!
So something that has always bothered me is the outrageous things you need to do to instantiate a generic array (perhaps I'm overreacting).
There are two methods presented EVERYWHERE:
1
2
3
4
5
6
| public <T> T[] alloc(Class<T> type, int length) {
return (T[])Array.newInstance(type, length);
}
public <T> T[] alloc(int length) {
return (T[])new Object[length];
} |
The first way sucks, you need to pass in the class type, which means whatever you have creating the array a user needs to pass in the class type... unnecessary code I daresay!
The second way sucks as well, doesn't work for me always, it's annoying. Especially in this case:
1
2
3
4
5
6
| public class Foo<X extends Bar> {
public X[] bars;
public Foo(int length) {
bars = (X[])new Object[length];
}
} |
NOPE, doesn't work... since X is at least type Bar, you need to do this:
1
2
3
4
5
6
| public class Foo<X extends Bar> {
public X[] bars;
public Foo(int length) {
bars = (X[])new Bar[length];
}
} |
Hey that works! Except you still have warnings... I don't like warnings, hence why I think both of these options suck.
So yesterday an alternative method POPPED in my head... something that is so simple, there's no casting, nothing ugly...
Somehow I haven't found ONE website or code example where someone does this, I feel like a god damn explorer (perhaps of the DORA quality).
1
2
3
4
5
| public class ArrayUtil {
public static <T> T[] alloc(int length, T ... base) {
return Arrays.copyOf( base, length );
}
} |
Boom. It's simple and can even be used in two different ways:
1
2
| String[] x = ArrayUtil.alloc(4);
String[] y = ArrayUtil.alloc(4, "first", "second"); |
You know how much ugly code exists in sooo many common libraries that require you to pass in Class<T> so it can create an array? I say they get rid of that silliness.
What say you?
