Java 覆盖整数比较？还是欺骗它？

我正在尝试编写一个通用堆类

import java.util.ArrayList;

public class heap<T extends Comparable<T>>
{
    private ArrayList<T> h;
    private int size;

    public heap()
    {
        h = new ArrayList<T>();
        h.add(null);
        size = 0;
    }

    public T getMin()
    {
        return h.get(1);
    }

    public T popMin()
    {
        T tmp = getMin();
        h.set(1, h.get(size));
        size--;
        sift(1);
        return tmp;
    }

    public void insert(T key)
    {
        h.add(key);
        percolate(++size);
    }

    public int getSize()
    {
        return this.size;
    }

    private int getLeftSon(int i)
    {
        return (i<<1<=size)? i<<1 : 0;
    }

    private int getRightSon(int i)
    {
         return ((i<<1)+1<=size)? (i<<1)+1 : 0;
    }

    private int getFather(int i)
    {
        return ((i>>1)!=0)? i>>1 : 0;
    }

    private void swap(int i, int j)
    {
        T tmp = h.get(i);
        h.set(i, h.get(j));
        h.set(j, tmp);
    }

    private void sift(int i) 
    {
        int son;
        do {
            son = 0;
            if (getLeftSon(i) != 0) 
            {
                son = getLeftSon(i);
                if (getRightSon(i) != 0 && h.get(getRightSon(i)).compareTo(h.get(getLeftSon(i))) > 0) 
                    son = getRightSon(i);
                if (h.get(son).compareTo(h.get(i)) <= 0) 
                    son = 0;
            }

            if (son!=0) {
                swap(i, son);
                i = son;
            }
         } while (son!=0);
    }

    private void percolate(int i) 
    {
        T key = h.get(i);

        while ((i > 1) && (key.compareTo(h.get(getFather(i))) > 0)) 
        {
            h.set(i, h.get(getFather(i)));
            i = getFather(i);
        }

        h.set(i, key);
    }
}

import java.util.ArrayList；
公共类堆
{
私人ArrayList h；
私有整数大小；
公共堆（）
{
h=新的ArrayList（）；
h、 添加（空）；
尺寸=0；
}
公共T getMin（）
{
返回h.get（1）；
}
公共T popMin（）
{
T tmp=getMin（）；
h、 set（1，h.get（size））；
大小--；
筛选（1）；
返回tmp；
}
公共无效插入（T键）
{
h、 添加（键）；
渗滤液（++粒度）；
}
公共int getSize（）
{
返回此.size；
}
私有整数getLeftSon（整数i）
{
return（i您可以让堆接受in构造函数，然后提供一个反转顺序的比较器

这就是比较器的实际用途——为给定类定义一个非自然的顺序，能够定义同一类的多个顺序，或者确实为一个不能修改的类定义一个顺序

例如，在构建时接受比较器的方法可以在中看到


示例代码存根：

public class Heap<T> { /* no need for items to extend Comparable anymore */
    private final Comparator<T> cmp;

    public Heap(Comparator<T> cmp) {
        this.cmp = cmp;
        ...
    }

    ...
}

公共类堆{/*不再需要对项进行扩展*/
私营最终比较国；
公共堆（比较器cmp）{
this.cmp=cmp；
...
}
...
}

…然后使用
cmp.compare（item1，item2）
无论您现在在哪里使用
item2.compareTo（item2）
，您可以让堆接受in构造函数，然后提供一个颠倒顺序的比较器

这就是比较器的实际用途——为给定类定义一个非自然的顺序，能够定义同一类的多个顺序，或者确实为一个不能修改的类定义一个顺序

例如，在构建时接受比较器的方法可以在中看到


示例代码存根：

public class Heap<T> { /* no need for items to extend Comparable anymore */
    private final Comparator<T> cmp;

    public Heap(Comparator<T> cmp) {
        this.cmp = cmp;
        ...
    }

    ...
}

公共类堆{/*不再需要对项进行扩展*/
私营最终比较国；
公共堆（比较器cmp）{
this.cmp=cmp；
...
}
...
}

…然后使用
cmp.compare（item1，item2）
现在使用
item2.compareTo（item2）
Integer是最后一个类，因此您无法扩展它。您想如何将compareTo的行为更改为？堆不应该知道元素比较。可能您正在尝试执行？无论如何，Integer实现与您的泛型签名匹配的Comparable。@LoganMzz这是关于“heap”的含义：@JiriTousek谢谢，我把“stack”搞混了：（Integer是最后一个类，因此您无法对其进行扩展。您想如何将compareTo的行为更改为？堆不应该知道元素比较。可能您正在尝试执行？无论如何，Integer实现与您的泛型签名匹配的Comparable。@LoganMzz这是关于“堆”的含义的）：@JiriTousek谢谢，我把它和“stack”混淆了（你能给我一个如何修改我的构造函数的例子吗？你能给我一个如何修改我的构造函数的例子吗？