Java 将类型对象强制转换为泛型

我知道这是一个非常草率的快速排序，但它是我必须使用的

我的问题是如何在线

x[k+i]=（E）（y[k]）

上将

y

数组的类型更改为

E

。我目前的做法并没有将对象强制转换为类型

E

。快速排序工作得很好（至少在递归之前），这只是此时的强制转换

public class quicksort {
    static <E extends Comparable<E>> E[] quickSort(E[] x, int i, int j) {
        int pivot = 0;
        Object[] y = new Object[j - i + 1];
        for (int k = 0; k < y.length; k++) y[k] = x[k + i];
        int lput = i;
        int rput = j;
        for (int k = i + 1; k <= j; k++) {
            if (x[k].compareTo(x[pivot]) < 0) {
                y[(lput++) - i] = x[k];
            } else {
                y[(rput--) - i] = x[k];
            }
        }

        pivot = lput;
        y[lput - i] = pivot;
        for (int k = 0; k < y.length; k++)
            x[k + i] = (E) (y[k]); // this line
        quickSort(x, i, pivot - 1);
        quickSort(x, pivot + 1, j);
        System.out.println("got here");
        return x;
    }
}

---

您可以通过传递一个，然后可以使用它创建一个使用JDK工厂方法的类型化的实例：

static <E extends Comparable<E>> E[] quickSort(Class<E> clazz, E[] x, int i, int j) {
    E[] y = (E[]) Array.newInstance(clazz, j - i + 1);
    ...
}

静态E[]快速排序（类clazz，E[]x，inti，intj）{
E[]y=（E[]）Array.newInstance（clazz，j-i+1）；
...
}

你所拥有的已经是最正确的方法了。它编译并运行良好

另一种方法是将数组创建为：

E[] y = (E[])new Comparable[j - i + 1];

然后当你把它拿出来的时候，你就不用扔了：

x[k + i] = (E) (y[k]);

---

但是，这有点危险，因为指向

y

的对象的实际运行时类是

可比较的[]

，而不是

E[]

，如果您意外地将

y

作为类型

E[]

暴露在方法外部，则可能会导致其他代码段中的崩溃，这是意外的。在这种方法中，您没有将

y

暴露在方法的外部，因此在这种情况下不会导致任何问题。

它如何不精确地工作？你有错误吗？我有一个类型不匹配，无法将对象转换为类型Eth，这是-

y

是一个

对象

数组，而不是

E

数组。尝试改用

集合

。对象不是Comparable的子类型，因此编译器无法为您强制转换，我想发布异常的完整堆栈跟踪。告诉我们它指的是哪一行。请注意，您在此处将int存储到对象数组中：

y[lput-i]=pivot

。这肯定是错误的。我很想知道为什么ppl不喜欢这个答案。它编译并解决了这个问题。

x[k + i] = (E) (y[k]);