Java Bubble Sort method for Object's fields

Question

I want to sort Token objects first based on their usedNumber bigger to smaller.
Then for the tokens have same usedNumber i want to sort them smaller to bigger based their priority number for example:
name priority usedNumber
a 1 3
b 2 4
c 3 0
d 4 3
e 5 3
f 6 4
Sorted version should be first bigger usedNumbers then smaller priorty:
b 2 4
f 6 4
a 1 3
d 4 3
e 5 3
c 3 0
Code below doesnt sort them correctly

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;
    }

Queue class in here is not from java.util. This is a class designed by me due the restrictions in my assigment. Queue class uses Arraylists to perform.

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);
    }
}
}

Answer 1

• Rather than wrapping ArrayList in your Queue , extend it: makes for simpler code
• Don't use "Token" as a generic class name: it's confusing. Rather use the standard T Which gives you code for Queue.java :

import java.util.ArrayList;

/*
 * If it's only ever used for Token, it could also be
 * public class Queue extends ArrayList<Token>
 *   and then you could override the sort method of ArrayList
 *   with the implementation shown in Token.sortSpecial below
 */
public class Queue<T> extends ArrayList<T> {

  private static final long serialVersionUID = 1L;

  public void removeFromFront() {
    super.remove(0);
  }

}

• Method for sorting queues in class Token should be static: it's not linked to the state of an instance. I've renamed it sortSpecial . It also doesn't have to return, as the sorting is done in place on the Queue
• Use List.sort with a custom Comparator to do the sorting
• Fields should be private with getters and setters (which are not shown here)

Which gives you Token.java :

public class Token {

  private String name;
  private int priority;
  private int usedNumber;

  public Token(String name, int priority, int usedNumber) {
    super();
    this.usedNumber = usedNumber;
    this.priority = priority;
    this.name = name;
  }

  /* Getters and Setters go here */

  /** Sort by usedNumber DESC / priority ASC */
  public static void sortSpecial(Queue<Token> queue) {
    queue.sort((x, y) -> {
      int comp = -Integer.compare(x.usedNumber, y.usedNumber);
      if (comp == 0)
        comp = Integer.compare(x.priority, y.priority);
      return comp;
    });
  }
  
  @Override
  public String toString() {
    return getClass().getSimpleName() + "[" + name + " (p=" + priority + ", un=" + usedNumber + ")]";
  }
  
}

Or if you want to play smart-ass, you could write the comparator as a one-liner (after defining your getters):

Comparator.comparingInt(Token::getUsedNumber).reversed().thenComparingInt(Token::getPriority)

Entry point for your program ( Main.java ):

public class Main {
  
  public static void main(String[] args) {
    Queue<Token> toks = new Queue<>();
    toks.add(new Token("a", 1, 3));
    toks.add(new Token("b", 2, 4));
    toks.add(new Token("c", 3, 0));
    toks.add(new Token("d", 4, 3));
    toks.add(new Token("e", 5, 3));
    toks.add(new Token("f", 6, 4));
    
    System.out.println("Input:");
    toks.stream().forEach(t -> System.out.println('\t' + t.toString()));
    System.out.println();
    
    Token.sortSpecial(toks);
    System.out.println("Output:");
    toks.stream().forEach(t -> System.out.println('\t' + t.toString()));
  }

}

Console output:

Input:
    Token[a (p=1, un=3)]
    Token[b (p=2, un=4)]
    Token[c (p=3, un=0)]
    Token[d (p=4, un=3)]
    Token[e (p=5, un=3)]
    Token[f (p=6, un=4)]

Output:
    Token[b (p=2, un=4)]
    Token[f (p=6, un=4)]
    Token[a (p=1, un=3)]
    Token[d (p=4, un=3)]
    Token[e (p=5, un=3)]
    Token[c (p=3, un=0)]