Java泛型：数组创建，类型转换和未经检查的警告

Question

I have following code, which is supposed to test different sorting algorithm implementations (& teach me generics) with arrays of different number types (Integer, Long, ...). Although I've gotten it to work, I was wondering if there can be improvements, specifically in 3 places where I've put FIXME .

Thanks..

package com.kash.test;

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

class SortTester<E extends Number> {
    E[] arr;
    E[] copyArr;
    Class<E> classOfElemType;
    int arrayLenToTestWith;

    @SuppressWarnings({ "unchecked" })
    SortTester(Class<E> cc, int ll) {
        classOfElemType = cc;
        arrayLenToTestWith = ll;
        arr = (E[]) Array.newInstance(classOfElemType, arrayLenToTestWith);
        copyArr = (E[]) Array.newInstance(classOfElemType, arrayLenToTestWith);
        for (int i = 0; i < arrayLenToTestWith; i++) {
            arr[i] = copyArr[i] = randomNumber();
        }
    }

    void reset() {
        System.arraycopy(copyArr, 0, arr, 0, arrayLenToTestWith);
    }

    E randomNumber() {
        // FIXME: Is tehre a way to do this without reflection?
        // FIXME: Also by converting the random() output to int we lose
        //        precision, anyway to avoid that without some "instanceof"
        //        kinda checks?
        try {
            // Every Number subclass, has a c'tor with a single String
            // arg, which represents an int.
            Constructor<E> ctor = classOfElemType.getConstructor(String.class);
            return ctor.newInstance(Integer.toString((int) (Math.random() * (arrayLenToTestWith * 2))));
        } catch (InstantiationException | IllegalAccessException | NoSuchMethodException | SecurityException
                | IllegalArgumentException | InvocationTargetException e) {
            System.err.println(e.getMessage());
            e.printStackTrace();
            e.getCause().printStackTrace();
        }
        return null;
    }

    void print() {
        for (int i = 0; i < arrayLenToTestWith; i++) {
            System.out.println(Array.get(arr, i));
        }
    }

    void test(/* sorters */) {
        // test the Sorter instances on our array for time and space..
        // for s in sorters
        // do
        // // start monitors..
        // s.sort(arr);
        // // stop monitors
        // reset();
        // done
        // // print results...
    }
}

public class Main<T extends Number> {

    public static void main(String[] args) {
        // FIXME: Is tehre a way to remove the unchecked warnings for Class below? Without
        //        using "@SuppressWarnings({ "unchecked" })"
        Class types[] = { Integer.class, Double.class, Float.class, Long.class, Short.class };
        for (Class cc : types) {
            SortTester<?> typeTester = new SortTester<>(cc, 10);
            System.out.println("Type = " + cc.getCanonicalName());
            typeTester.print();
        }
        // Class<?> types2[] = { Integer.class, Double.class, Float.class, Long.class, Short.class };
        // for (Class<?> cc1 : types) {
        // SortTester<cc1> typeTester = new SortTester<>(cc1, 10);
        // typeTester.print();
        // }
    }
}

---- edit ----

class above is meant to test following interface :

package com.kash.src;

import java.util.Comparator;
import java.util.List;

/**
 * 
 * Interface that provides all sorting functions for all possible representations
 * of a list of Objects (non-primitive types). <br>
 * 
 * - {@link List}<{@link Comparable}><br>
 * - Array of < ? extends {@link Comparable}><br>
 * - {@link List}< ? > with external {@link Comparator}<br>
 * - Array of < ? > with external {@link Comparator}<br>
 * 
 * @author Kashyap Bhatt
 * 
 * @param <T>
 */

public interface Sorter {
    <T extends Comparable<? super T>> void sort(List<T> list);

    <T extends Comparable<? super T>> void sort(T[] array);

    <T extends Object> void sort(List<T> list, Comparator<? super T> c);

    <T extends Object> void sort(T[] array, Comparator<? super T> c);
}

Answer 1

As a good general rule, never use an array when you could use a Collection .

This is how I would initialize the types variable:

List<Class<? extends Number>> types = Arrays.<Class<? extends Number>>asList( Integer.class, Double.class, Float.class, Long.class, Short.class );

The rest of your code will work unchanged.