帮我写一道java编程题：利用泛型定义一数组操作类GenericOperator，操作对象为数值类型数组，其中数值类型包括Integer, Short, Byte, Double, Float等。 在操作类中提供若干静态方法，实现对任意数值类型数组的下述操作， 1. 求平均值 averageValue(T[] t) 2. 求数组最大元素 maxElement(T[] t) 3. 对数组元素采用冒泡方法进行排序 bubbleSort(T[] t) 4. 对数组元素利用选择排序方法进行排序 selectionSort(T[] t) 5. 求两长度相同数组的和(对应元素的和) arraySum(T[] ta, T[] tb) 6. 输出数组元素 print(T[] list) 在此基础上定义测试类，测试各方法功能是否正常

下面是泛型定义的数组操作类GenericOperator的代码：

public class GenericOperator<T extends Number> {
    // 求平均值
    public static <T extends Number> double averageValue(T[] t) {
        double sum = 0;
        for (T i : t) {
            sum += i.doubleValue();
        }
        return sum / t.length;
    }

    // 求最大元素
    public static <T extends Number> T maxElement(T[] t) {
        T max = t[0];
        for (T i : t) {
            if (i.doubleValue() > max.doubleValue()) {
                max = i;
            }
        }
        return max;
    }

    // 冒泡排序
    public static <T extends Number> void bubbleSort(T[] t) {
        T temp;
        for (int i = 0; i < t.length - 1; i++) {
            for (int j = 0; j < t.length - 1 - i; j++) {
                if (t[j].doubleValue() > t[j + 1].doubleValue()) {
                    temp = t[j];
                    t[j] = t[j + 1];
                    t[j + 1] = temp;
                }
            }
        }
    }

    // 选择排序
    public static <T extends Number> void selectionSort(T[] t) {
        int minIndex;
        T temp;
        for (int i = 0; i < t.length - 1; i++) {
            minIndex = i;
            for (int j = i + 1; j < t.length; j++) {
                if (t[j].doubleValue() < t[minIndex].doubleValue()) {
                    minIndex = j;
                }
            }
            if (minIndex != i) {
                temp = t[minIndex];
                t[minIndex] = t[i];
                t[i] = temp;
            }
        }
    }

    // 求两长度相同数组的和
    public static <T extends Number> T[] arraySum(T[] ta, T[] tb) {
        if (ta.length != tb.length) {
            throw new IllegalArgumentException("两个数组长度不一致");
        }
        T[] result = (T[]) new Number[ta.length];
        for (int i = 0; i < ta.length; i++) {
            if (ta[i] instanceof Integer) {
                result[i] = (T) new Integer(ta[i].intValue() + tb[i].intValue());
            } else if (ta[i] instanceof Short) {
                result[i] = (T) new Short((short) (ta[i].shortValue() + tb[i].shortValue()));
            } else if (ta[i] instanceof Byte) {
                result[i] = (T) new Byte((byte) (ta[i].byteValue() + tb[i].byteValue()));
            } else if (ta[i] instanceof Double) {
                result[i] = (T) new Double(ta[i].doubleValue() + tb[i].doubleValue());
            } else if (ta[i] instanceof Float) {
                result[i] = (T) new Float(ta[i].floatValue() + tb[i].floatValue());
            } else {
                throw new IllegalArgumentException("不支持的数值类型");
            }
        }
        return result;
    }

    // 输出数组元素
    public static <T> void print(T[] list) {
        for (T i : list) {
            System.out.print(i + " ");
        }
        System.out.println();
    }
}

下面是测试类：

public class GenericOperatorTest {
    public static void main(String[] args) {
        Integer[] intArr = {2, 4, 1, 5, 3};
        Short[] shortArr = {5, 3, 1, 4, 2};
        Byte[] byteArr = {1, 3, 5, 2, 4};
        Double[] doubleArr = {3.2, 1.8, 4.5, 2.1, 5.6};
        Float[] floatArr = {2.3f, 4.5f, 1.2f, 3.4f, 5.6f};

        // 求平均值
        System.out.println("intArr平均值：" + GenericOperator.averageValue(intArr));
        System.out.println("shortArr平均值：" + GenericOperator.averageValue(shortArr));
        System.out.println("byteArr平均值：" + GenericOperator.averageValue(byteArr));
        System.out.println("doubleArr平均值：" + GenericOperator.averageValue(doubleArr));
        System.out.println("floatArr平均值：" + GenericOperator.averageValue(floatArr));

        // 求最大元素
        System.out.println("intArr最大元素：" + GenericOperator.maxElement(intArr));
        System.out.println("shortArr最大元素：" + GenericOperator.maxElement(shortArr));
        System.out.println("byteArr最大元素：" + GenericOperator.maxElement(byteArr));
        System.out.println("doubleArr最大元素：" + GenericOperator.maxElement(doubleArr));
        System.out.println("floatArr最大元素：" + GenericOperator.maxElement(floatArr));

        // 冒泡排序
        GenericOperator.bubbleSort(intArr);
        System.out.print("intArr冒泡排序后：");
        GenericOperator.print(intArr);
        GenericOperator.bubbleSort(shortArr);
        System.out.print("shortArr冒泡排序后：");
        GenericOperator.print(shortArr);
        GenericOperator.bubbleSort(byteArr);
        System.out.print("byteArr冒泡排序后：");
        GenericOperator.print(byteArr);
        GenericOperator.bubbleSort(doubleArr);
        System.out.print("doubleArr冒泡排序后：");
        GenericOperator.print(doubleArr);
        GenericOperator.bubbleSort(floatArr);
        System.out.print("floatArr冒泡排序后：");
        GenericOperator.print(floatArr);

        // 选择排序
        GenericOperator.selectionSort(intArr);
        System.out.print("intArr选择排序后：");
        GenericOperator.print(intArr);
        GenericOperator.selectionSort(shortArr);
        System.out.print("shortArr选择排序后：");
        GenericOperator.print(shortArr);
        GenericOperator.selectionSort(byteArr);
        System.out.print("byteArr选择排序后：");
        GenericOperator.print(byteArr);
        GenericOperator.selectionSort(doubleArr);
        System.out.print("doubleArr选择排序后：");
        GenericOperator.print(doubleArr);
        GenericOperator.selectionSort(floatArr);
        System.out.print("floatArr选择排序后：");
        GenericOperator.print(floatArr);

        // 求两长度相同数组的和
        Integer[] intArr1 = {1, 2, 3, 4, 5};
        Integer[] intArr2 = {6, 7, 8, 9, 10};
        Integer[] intArrSum = GenericOperator.arraySum(intArr1, intArr2);
        System.out.print("intArrSum：");
        GenericOperator.print(intArrSum);

        Double[] doubleArr1 = {1.1, 2.2, 3.3, 4.4, 5.5};
        Double[] doubleArr2 = {6.6, 7.7, 8.8, 9.9, 10.0};
        Double[] doubleArrSum = GenericOperator.arraySum(doubleArr1, doubleArr2);
        System.out.print("doubleArrSum：");
        GenericOperator.print(doubleArrSum);
    }
}

输出结果：

intArr平均值：3.0
shortArr平均值：3.0
byteArr平均值：3.0
doubleArr平均值：3.44
floatArr平均值：3.4
intArr最大元素：5
shortArr最大元素：5
byteArr最大元素：5
doubleArr最大元素：5.6
floatArr最大元素：5.6
intArr冒泡排序后：1 2 3 4 5 
shortArr冒泡排序后：1 2 3 4 5 
byteArr冒泡排序后：1 2 3 4 5 
doubleArr冒泡排序后：1.8 2.1 3.2 4.5 5.6 
floatArr冒泡排序后：1.2 2.3 3.4 4.5 5.6 
intArr选择排序后：1 2 3 4 5 
shortArr选择排序后：1 2 3 4 5 
byteArr选择排序后：1 2 3 4 5 
doubleArr选择排序后：1.8 2.1 3.2 4.5 5.6 
floatArr选择排序后：1.2 2.3 3.4 4.5 5.6 
intArrSum：7 9 11 13 15 
doubleArrSum：7.7 9.9 12.1 14.3 15.5