Java 最差拟合启发式优先级队列的比较器

我正在尝试使用最差拟合启发式编写一个垃圾箱打包程序，以便it将权重添加到垃圾箱中，直到文件读取垃圾箱时无法再存储，并将垃圾箱序列放入优先级队列中，以便将剩余空间最少的垃圾箱放在顶部。但是我在编写Bin类的比较器时遇到了麻烦。以下是完整的代码：

public class BinPacking{

    public static class Bin implements Comparable<Bin> {

        int ID ;
        int remSpace;
        ArrayList<Integer> weights = new ArrayList<Integer>();

        public Bin(int ID){
            this.ID = ID;
            remSpace = 100;
        }

        public void add(int size){
            remSpace -= size;
            weights.add(size);
        }

        @Override
        public int compareTo(Bin o) {
            return remSpace;
        }

}



    public static void main(String[] args) throws FileNotFoundException{


        PriorityQueue<Bin> pq =new PriorityQueue<Bin>();

        File myFile = new File("input.txt");

        int binId = 1;
        Bin d = new Bin(binId);
        pq.add(d);
        int size;


        Scanner input = new Scanner(myFile); 

        while (input.hasNext())
        {

            size = input.nextInt();

            d = (Bin)pq.peek();

            if (d.remSpace >= size)
            {
                pq.remove(d);
                d.add(size);
                pq.add(d);

            }
            else
            {
                binId++;
                d = new Bin(binId);
                d.add(size);
                pq.add(d);



            }
      }
       System.out.println("Number of bins used: " + binId); 

       int mylst[][] = new int[binId][1000];
       int k =1;
       for(int i=0;i<binId;i++){
           System.out.println("Bin" + k + ": ");
           k++;
           for(int j=0;j<pq.peek().weights.size();j++){

              mylst[i][j] = pq.peek().weights.get(j);
              System.out.print(" "+mylst[i][j]);
           }
          System.out.println();
           pq.poll();
       }



    }
}

公共类装箱{
公共静态类Bin实现了可比性{
int-ID；
内部空间；
ArrayList权重=新的ArrayList（）；
公共Bin（内部ID）{
this.ID=ID；
remSpace=100；
}
公共空白添加（整数大小）{
remSpace-=大小；
重量。添加（尺寸）；
}
@凌驾
公共内部比较（Bin o）{
返回空间；
}
}
公共静态void main（字符串[]args）引发FileNotFoundException{
PriorityQueue pq=新的PriorityQueue（）；
File myFile=新文件（“input.txt”）；
int-binId=1；
Bin d=新Bin（binId）；
pq.增加（d）；
整数大小；
扫描仪输入=新扫描仪（myFile）；
while（input.hasNext（））
{
size=input.nextInt（）；
d=（Bin）pq.peek（）；
如果（d.remSpace>=大小）
{
pq.移除（d）；
d、 添加（大小）；
pq.增加（d）；
}
其他的
{
binId++；
d=新箱子（binId）；
d、 添加（大小）；
pq.增加（d）；
}
}
System.out.println（“使用的箱子数量：“+binId”）；
int mylst[][]=new int[binId][1000]；
int k=1；
for（int i=0；i用于返回两个对象之间的差值，允许算法决定一个项目i是否等于、小于或大于另一个项目。返回一个项目的剩余空间不会给出超出您所需的顺序，因为这不会比较两个对象。请尝试：

public int compareTo(Bin o) {
     if(o == null)return 1;
     if(remSpace > o.remSpace)return 1;
     else if(remSpace < o.remSpace)return -1;
     return 0;
}

public int compareTo（Bin o）{
如果（o==null）返回1；
如果（remSpace>o.remSpace）返回1；
else if（remSpace

请注意，它如何返回两个存储箱空间的差异，以便测量差异。
虽然是边缘情况，但不建议使用直接减法，因为溢出会产生错误的结果。典型的方法是实际执行比较，并根据需要返回-1、0或1。此外，还要防止空值是值得的。老实说，在这种情况下，这可能不是问题，因为我无法想象其他任何合理的代码会将负值赋给
remSpace
，因此不会发生溢出。请记住：）