在Java中创建数组堆

因此，我尝试创建一个基于数组的泛型堆，用于我的tester类。我所拥有的大部分知识都是基于我对树木的理解和一些在线研究以及我的教科书；两者都有非常有限的信息，我在寻找什么。但是，我确实设法获得了所有需要的方法，当我运行它时，我得到了以下错误：

Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.Comparable;
    at q1.Heaps.<init>(Heaps.java:23)
    at q1.createGui.<init>(Gui.java:46)
    at q1.Gui.main(Gui.java:18)  

线程“main”java.lang.ClassCastException:[Ljava.lang.Object；中的异常；无法转换为[Ljava.lang.Compariable； 在q1.Heaps。（Heaps.java:23） 在q1.createGui（Gui.java:46） 位于q1.Gui.main（Gui.java:18） 我猜这与我如何声明和初始化我的可比数组有关，我很难弄清楚如何声明和初始化可比数组

package q1;

import java.util.Arrays;


public class Heaps<E extends Comparable<E>> {

    Comparable[] data;
    int size;

    /**
     * Constructor with s as size
     */
    @SuppressWarnings("unchecked")
    public Heaps(int s) {
        size = 0;
        data = (E[]) new Object[s];
    }

    /**
     * Adds a value to the heap
     */
    public void add(E value) {
        if (full()) // expand array
            ensureCapacity(2*size);
        size++;
        data[size] = value;
        if (size > 1)
            heapifyUp();
    }

    /**
     * Checks if the array is full
     */
    private boolean full()
    { 
        return (size == data.length-1);
    }

    private void heapifyUp()
    {
        Comparable<E> temp;
        int next = size;
        while (next != 1 && data[next].compareTo(data[next/2]) > 0)
        {
            temp = data[next];
            data[next] = data[next/2];
            data[next/2] = temp;
            next = next/2;
        }
    }

    private void heapifyDown()
    {
        Comparable<E> temp;
        int next = 0;
        while (next*2 <= size) // node has a child
        {
            int child = 2*next; // left child
            if (child < size &&
                    data[child].compareTo(data[child+1]) > 0)//left smaller than right
                child++; // right child instead
            if (data[next].compareTo(data[child]) > 0)
            {
                temp = data[next];
                data[next] = data[child];
                data[child] = temp;
                next = child;
            }
            else;
            next = size; // stop loop
        }//end while
    }

    /**
     * Removes all occurrence of element
     */
    public boolean removeAll(E element) {
        if (contains(element) && !(isEmpty())){
            for (int i = 0; i < size; i++){
                if(element.equals(data[i])){
                    data[i] = data[size-1];
                }
                heapifyDown();
            }
            return true;
        }
        return false;
    }

    /**
     * Removes 1st occurrence of element
     */
    public boolean remove(E element) {
        if (contains(element) && !(isEmpty())){
            for (int i = 0; i < size; i++){
                if(element.equals(data[i])){
                    data[i] = data[size-1];
                    heapifyDown();
                    return true;
                }   
            }
        }
        return false;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public Comparable<E>[] ensureCapacity(int s) {
        return Arrays.copyOf(data, 2*s);
    }

    /**
     * Converts the heap into its String representation.
     *   @return the String representation
     */

    public Comparable<E>[] iteratorPreOrder() 
    {
        Comparable<E>[] temp = (E[]) new Object[size];
        temp[0] = data[0];
        int i = 1;
        int count = 1;
        while(data[2*i] != null){
            temp[count] = data[2*i];
            ++i;
            ++count;
        }
        i = 1;
        while(data[(2*i) +1] != null){
            temp[count] = data[(2*i) +1];
            ++i;
            ++count;
        }
        return temp;
    }


    public int countOccurance(E element){
        int count = 0;
        for (int i =0; i < size; i++){
            if(element.equals(data[i])){
                count++;
            }
        }
        return count;
    }

    public boolean contains (E element) 
    {
        for (int i=0; i<size; i++){
            if (element.equals(data[i])){
                return true;
            }
        }
        return false;
    }
}

q1包；
导入java.util.array；
公共类堆{
可比[]数据；
整数大小；
/**
*大小为s的构造函数
*/
@抑制警告（“未选中”）
公共堆（int-s）{
尺寸=0；
数据=（E[]）新对象；
}
/**
*向堆中添加一个值
*/
公共无效添加（E值）{
if（full（））//展开数组
保证容量（2*尺寸）；
大小++；
数据[大小]=值；
如果（大小>1）
heapifyUp（）；
}
/**
*检查数组是否已满
*/
私有布尔满（）
{ 
返回值（大小==data.length-1）；
}
私有void heapifyUp（）
{
可比温度；
int next=大小；
while（next！=1&&data[next].compareTo（data[next/2]）>0
{
温度=数据[下一步]；
数据[下一步]=数据[下一步/2]；
数据[下一个/2]=温度；
下一个=下一个/2；
}
}
私有void heapifyDown（）
{
可比温度；
int next=0；
while（next*2 0）//左小于右
child++；//改为右child
如果（数据[next].compareTo（数据[child]）>0
{
温度=数据[下一步]；
数据[下一步]=数据[子项]；
数据[子项]=温度；
下一个=孩子；
}
其他的
next=size；//停止循环
}//结束时
}
/**
*删除元素的所有引用
*/
公共布尔removeAll（E元素）{
if（包含（元素）&&！（isEmpty（））{
对于（int i=0；i对于（int i=0；i您正在创建一个对象[]，然后尝试将其强制转换为可压缩[]。编译器正在告诉您未检查强制转换错误的错误

您希望数据为
E[]data
，且行为：

data = new E[s];

注意：这可能会遇到Java如何处理泛型的问题。
您已经把问题的根源明确了：
data=（E[]）构造函数中的新对象确实是problem@Chris是的，但现在我只需要一个解决方案：（对于您的编辑，请参阅-泛型类型的数组是不允许的，因为它们不健全。问题是由于Java数组（不是静态健全的，而是动态检查的）与泛型（是静态健全的，而不是动态检查的）的交互。我不确定它是否能够创建E[]类型的数组由于类型擦除。手头没有IDE可供检查。编译器不允许我使用data=new E[s]当我遇到错误时：无法创建E的泛型数组。是的，我担心会发生类似的情况。请尝试以下想法之一：@KonstantinNaryshkin有趣，但我成功了，请查看我编辑的帖子。@KonstantinNaryshkin-请编辑您的答案以使其更正确-因为代码不正确，它可能会引起负面注意。