在java中使用泛型排序数组时出现编译时错误

这是我的密码：

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;

public class SortingUsingGenerics {

    public static void main(String[] args) {
        Integer[] intArray = {1,5,4,2,10};
        String[] stringArray = {"Ä","X","C","B","M"};
        Float[] floatArray = {1.5f,2.8f,0.5f,10.3f,9.5f};

        // Sort and Print
        printArray(sortArray(intArray));
        printArray(sortArray(stringArray));
        printArray(sortArray(floatArray));

    }

    private static <MyArray> void printArray(MyArray[] inputArray) {
        for (MyArray element : inputArray) {
            System.out.print(element);
        }
        System.out.println();
    }

    public static <E> E[] sortArray(E[] inputArray){

        if (inputArray instanceof Integer[]){
            Collections.sort(Arrays.asList(inputArray),new Comparator<Integer>() {
                        public int compare(Integer o1, Integer o2) {
                            if (o1 == o2) {
                                return 0;
                            } else if (o1 > 02) {
                                return 1;
                            } else {
                                return -1;
                            }
                        }

                    });
        }
        return inputArray;
    }
}

导入java.util.array；
导入java.util.Collections；
导入java.util.Comparator；
使用泛型的公共类排序{
公共静态void main（字符串[]args）{
整数[]intArray={1,5,4,2,10}；
String[]stringArray={“Ä”，“X”，“C”，“B”，“M”}；
Float[]floatArray={1.5f，2.8f，0.5f，10.3f，9.5f}；
//分类和打印
打印阵列（sortArray（intArray））；
printArray（sortArray（stringArray））；
printArray（sortArray（floatArray））；
}
私有静态void printary（MyArray[]inputArray）{
for（MyArray元素：inputArray）{
系统输出打印（元素）；
}
System.out.println（）；
}
公共静态E[]sortArray（E[]输入阵列）{
if（整数[]的inputArray实例）{
Collections.sort（Arrays.asList（inputArray），新的Comparator（）{
公共整数比较（整数o1，整数o2）{
如果（o1==o2）{
返回0；
}否则如果（o1>02）{
返回1；
}否则{
返回-1；
}
}
});
}
返回输入；
}
}

我得到的错误是：

---

sort（List，Comparator您的
instanceof
检查方法并没有真正告诉编译器
inputArray
是一个
Integer[]
——编译时类型仍然是
E[]

但是，您可以非常轻松地进行施法，在这一点上它将起作用：

if (inputArray instanceof Integer[]) {
    Integer[] integers = (Integer[]) inputArray;
    Collections.sort(Arrays.asList(integers), ...);
}

甚至只是：

if (inputArray instanceof Integer[]) {
    Collections.sort(Arrays.asList((Integer[]) inputArray), ...);
}

然而，当你有一个泛型方法，然后为特定类型做特定的事情时，你至少应该考虑到底是真的想要一个泛型方法吗？< /p> 在这个场景中，如果数组是<代码>整数[]/COD>，<代码>浮点[] /代码>，或者<代码>字符串[3]，那么决定做什么没有多大价值。

-它们都实现了

可比

接口。由于该方法不允许它，因此对任何不可比的东西进行排序也没有意义-我们不允许传递一个自定义的

比较器

，以解决此问题

在这种情况下，最理想的情况是依靠

compariable

的自然行为，而不是手工编写的比较方法

public static <E extends Comparable<E>> E[] sortArray(E[] inputArray){
    Collections.sort(Arrays.asList(inputArray), new Comparator<E>() {
        @Override
        public int compare(E o1, E o2) {
            return o1.compareTo(o2);
        }

    });
    return inputArray;
}

publicstatice[]sortArray（E[]inputArray）{
Collections.sort（Arrays.asList（inputArray），新的Comparator（）{
@凌驾
公共整数比较（EO1，EO2）{
返回o1。与（o2）相比；
}
});
返回输入；
}

---

这种方法确保您传入的任何

E

都是一个

可比较的
，因此您可以简单地将每个对象的
比较委托给
方法，同时保留匿名
比较器
上绑定的所需类型，顺便说一句
否则（o1>02）
是一个bug。（
02
是数字
2
的八进制文字）这就是我所需要的..感谢快速解决方案。