对象的Java气泡排序方法'；s场

我想首先根据令牌对象使用的数字从大到小对其进行排序。
然后，对于具有相同usedNumber的令牌，我希望根据其优先级编号将其从小到大排序，例如：
使用的名称优先级编号
a 13
b 2 4
C30
d 4 3
e 5 3
f 6 4
排序后的版本应先使用较大的数字，然后再使用较小的数字：
b 2 4
f 6 4
a 13
d 4 3
e 5 3
C30
下面的代码没有正确排序

public class Token {
    int usedNumber;
    int priority;
    String name;
    public  Queue<Token> reversebubbleSort(Queue<Token> queue)
    {
        int n = queue.size();
        int i;
        int j;
        Token temp;
        boolean swapped;
        for (i = 0; i < n - 1; i++)
        {
            swapped = false;
            for (j = 0; j < n - i - 1; j++)
            {
                int namenumber1 = Integer.parseInt(queue.get(j).priority);
                int namenumber2 = Integer.parseInt(queue.get(j+1).priority);
                int number1 = queue.get(j).getUsedNumber();
                int number2 = queue.get(j+1).getUsedNumber();
                if (((number1^5)-namenumber1) < ((number2^5)-namenumber2))
                {
                    // swap arr[j] and arr[j+1]
                    temp = queue.get(j);
                    queue.set(j, queue.get(j+1));
                    queue.set(j+1, temp);
                    swapped = true;
                }
            }
            // IF no two elements were
            // swapped by inner loop, then break
            if (swapped == false)
                break;
        }
        return queue;
    }

公共类令牌{
int-usedNumber；
int优先级；
字符串名；
公共队列反向二进制排序（队列队列）
{
int n=queue.size（）；
int i；
int j；
令牌温度；
布尔交换；
对于（i=0；i

这里的队列类不是来自java.util。这是我设计的一个类，由于我的分配中的限制。队列类使用ArrayList来执行

public class Queue<Token>  {
    private ArrayList<Token> queue;
    public Queue() {
        queue = new ArrayList<>();
    }

    public void add(Token addItem){
        //In queues, adding in the back, first in first out.
        queue.add(addItem);
    }
    public void removeFromFront(){
        queue.remove(0);
    }
    public int size(){
        return queue.size();
    }


    public Token get(int location){
        return queue.get(location);
    }
    public void remove(int index){
        queue.remove(index);
    }

    public void set(int location, Token setItem) {
        queue.set(location, setItem);
    }
}
}

公共类队列{
私有数组列表队列；
公共队列（）{
queue=newarraylist（）；
}
公共无效添加（令牌添加项）{
//在队列中，在后面添加，先进先出。
queue.add（addItem）；
}
public void removeFromFront（）{
队列。删除（0）；
}
公共整数大小（）{
返回queue.size（）；
}
公共令牌获取（int位置）{
返回队列.get（位置）；
}
公共无效删除（整型索引）{
队列。删除（索引）；
}
公共无效集（int位置，令牌setItem）{
queue.set（位置，setItem）；
}
}
}

• 与其在

  队列中包装
  ArrayList
  ，不如扩展它：使代码更简单

• 不要使用“Token”作为泛型类名：这很容易混淆。而是使用标准的T 这为您提供了Queue.java的代码：

import java.util.ArrayList；
/*
*如果它只用于代币，它也可以
*公共类队列扩展了ArrayList
*然后可以重写ArrayList的排序方法
*其实现如下面的Token.sortSpecial所示
*/
公共类队列扩展了ArrayList{
私有静态最终长serialVersionUID=1L；
public void removeFromFront（）{
super.remove（0）；
}
}

• 在类

  令牌中对队列进行排序的方法应该是静态的：它不链接到实例的状态。我已将其重命名为
  sortSpecial
  。它也不必返回，因为排序是在
  队列上就地完成的

• 使用

  List.sort

  和自定义

  比较器进行排序

• 字段应该是getter和setter的私有字段（此处未显示）

这将为您提供Token.java：

公共类令牌{
私有字符串名称；
私人优先权；
私人使用号码；
公共令牌（字符串名称、int优先级、int usedNumber）{
超级（）；
this.usedNumber=usedNumber；
优先权=优先权；
this.name=名称；
}
/*能手和二传手都在这里*/
/**按使用的编号说明/优先级ASC排序*/
公共静态无效排序特殊（队列）{
queue.sort（（x，y）->{
int comp=-Integer.compare（x.usedNumber，y.usedNumber）；
如果（comp==0）
comp=整数。比较（x.优先级，y.优先级）；
返回补偿；
});
}
@凌驾
公共字符串toString（）{
返回getClass（）.getSimpleName（）+“[”+name+“（p=“+priority+”，un=“+usedNumber+”）”；
}
}

或者，如果您想玩“聪明驴”，您可以将比较器编写为一行代码（在定义getter之后）：

Comparator.comparingit（标记：：getUsedNumber）.reversed（）。然后比较（标记：：getPriority）

程序的入口点（Main.java）：

公共类主{
公共静态void main（字符串[]args）{
Queue toks=新队列（）；
添加（新标记（“a”，1，3））；
添加（新标记（“b”，2，4））；
添加（新标记（“c”，3，0））；
添加（新标记（“d”，4，3））；
添加（新标记（“e”，5，3））；
添加（新标记（“f”，6，4））；
System.out.println（“输入：”）；
toks.stream（）.forEach（t->System.out.println（'\t'+t.toString（））；
System.out.println（）；
Token.sortSpecial（toks）；
System.out.println（“输出：”）；
toks.stream（）.forEach（t->System.out.println（'\t'+t.toString（））；
}
}

控制台输出：

输入：
代币[a（p=1，un=3）]
令牌[b（p=2，un=4）]
代币[c（p=3，un=0）]
代币[d（p=4，un=3）]
代币[e（p=5，un=3）]
代币[f（p=6，un=4）]
输出：
令牌[b（p=2，un=4）]
代币[f（p=6，un=4）]
代币[a（p=1，un=3）]
代币[d（p=4，un=3）]
代币[e（p=5，un=3）]
代币[c（p=3，un=0）]

您的作业需要执行此冒泡排序还是仅对队列进行排序？不需要执行冒泡排序。可以使用不同的排序方法进行排序