Java数组泛型的小疑问

一、今天看书，看到泛型这一章，手痒痒地写了个小例子。

public class GenericTypeTest {

    public static void main(String[] args) {
        // 用一下Holder类喽
        Holder<String> h = new Holder<String>("Hello World");
        System.out.println(h);
    }

    static class Holder<T> {
        private T data;

        public Holder(T in) {
            data = in;
        }

        @Override
        public String toString() {
            return data.toString();
        }
    }
}

结果打印出来当然是：

Hello World

二、然后我想，能不能把数组类型传进去呢

    public static void main(String[] args) {
        // 用一下Holder类喽
        // Holder<String> h = new Holder<String>("Hello World");
        Holder<int[]> h2 = new Holder<int[]>(new int[] { 1, 2, 3, 4, 5 });
        System.out.println(h2);
    }

这样是可以编译通过的唉，打印出的结果是：

[I@5e55ab

可以看到，这是一个"[I"（int数组），地址是5e55ab。

三、但是我想打出数组里面的东东看唉

于是我又改了一下程序

public class GenericTypeTest {

    public static void main(String[] args) {
        // 用一下Holder类喽
        // Holder<String> h = new Holder<String>("Hello World");
        Holder<int[]> h2 = new Holder<int[]>(new int[] { 1, 2, 3, 4, 5 });
        System.out.println(h2);
    }

    static class Holder<T> {
        private T data;

        public Holder(T in) {
            data = in;
        }

        @Override
        public String toString() {
            if (data.getClass().isArray()) {
                if (data.getClass().toString().startsWith("class [I")) {
                    return Arrays.toString((int[]) data);
                }
            }
            return data.toString();
        }
    }
}

这样的确是可以打印出我想要的结果：[1, 2, 3, 4, 5]

但是，面对如此多的数组类型，我要一个一个都判断吗，有什么方法能直接取到数组的成员呢？

又稍加完善：

public class GenericTypeTest {

    public static void main(String[] args) {
        // 用一下Holder类喽
        // Holder<String> h = new Holder<String>("Hello World");
        System.out.println(new Holder<int[]>(new int[] { 1, 1, 1 }));
        System.out.println(new Holder<byte[]>(new byte[] { 2, 2, 2 }));
        System.out.println(new Holder<short[]>(new short[] { 3, 3, 3 }));
        System.out.println(new Holder<long[]>(new long[] { 4L, 4L, 4L }));
        System.out.println(new Holder<float[]>(new float[] { 5F, 5F, 5F }));
        System.out.println(new Holder<double[]>(new double[] { 6, 6, 6 }));
        System.out.println(new Holder<char[]>(new char[] { 'a', 'b', 'c' }));
        System.out.println(new Holder<boolean[]>(new boolean[] { true, true, false }));
        System.out.println(new Holder<String[]>(new String[] { "hello", "world" }));
    }

    static class Holder<T> {
        private T data;

        public Holder(T in) {
            data = in;
        }

        @Override
        public String toString() {
            Class<?> clz = data.getClass();
            if (clz.isArray()) {
                String className = data.getClass().getName();
                if (className.toString().equals("[I")) {
                    return Arrays.toString((int[]) data);
                } else if (className.toString().equals("[B")) {
                    return Arrays.toString((byte[]) data);
                } else if (className.toString().equals("[S")) {
                    return Arrays.toString((short[]) data);
                } else if (className.toString().equals("[J")) {
                    return Arrays.toString((long[]) data);
                } else if (className.toString().equals("[F")) {
                    return Arrays.toString((float[]) data);
                } else if (className.toString().equals("[D")) {
                    return Arrays.toString((double[]) data);
                } else if (className.toString().equals("[C")) {
                    return Arrays.toString((char[]) data);
                } else if (className.toString().equals("[Z")) {
                    return Arrays.toString((boolean[]) data);
                } else if (className.toString().startsWith("[L")) {
                    return Arrays.toString((Object[]) data);
                }
            }
            return data.toString();
        }
    }
}

对于基本类型数组，必须要拿出来单独处理，类数组可以转成Object[]，然后取出其中的成员。

四、后话，对于一般的类数组，我们将它强转为Object[]数组，然后取得一个一个的Object成员，那能不能将Object成员强转成更具体的类型呢？

目前我还没有找到转换的方法-v-

added 2014-02-08 后来看了书，自己也寻思了寻思，的确，泛型根本不是用来做这个的啊，这种问题在实际中是不会出现的吧。