Trying to sort a Circularqueue and rearrange another queue according to the sorted one

Question

As i mentioned, I am trying to sort a Circular queue and rearrange another Circularqueue according to the sorted one. I know it is too beginner for stackoverflow but it is my last chance.

The part of the algorithm that sort but not working properly. I created two temp one for name and one for the numbers. Then search the max in the scores but could not

int size = scores.size();
            for(int i = 0; i<size; i++){
                int max = 0;
                for(int j = 0; j< scores.size(); j++){
                    if((int) scores.peek()> max){
                        max = (int) scores.peek();
                        scores.enqueue(scores.dequeue());
                    }
                    else{
                        scores.enqueue(scores.dequeue());
                    }
                }
                int size2 = scores.size();
                for(int j = 0; j<size2; j++){
                    if((Integer.parseInt(String.valueOf(scores.peek())) == max)){
                        temp_scores.enqueue(scores.dequeue());
                        temp_names.enqueue(names.dequeue());
                        break;
                    }
                    else{
                        scores.enqueue(scores.dequeue());
                        names.enqueue(names.dequeue());
                    }
                }
                int size3 = temp_names.size();
                for(int j = 0; j<size3; j++){
                    scores.enqueue(temp_scores.dequeue());
                    names.enqueue(temp_names.dequeue());
                }
            }
            System.out.println();

public class CircularQueue {

private int rear;
private int front;
private Object[] elements;

public CircularQueue(int capacity)
{
    rear=-1;
    front=0;
    elements=new Object[capacity];
}

public void enqueue(Object data)
{
    if (isFull())
    {

    }
    else
    {
        rear=(rear+1)%elements.length;
        elements[rear]=data;
    }
}

public Object dequeue()
{
    if (isEmpty())
    {

        return null;
    }
    else
    {
        Object retdata= elements[front];
        elements[front]=null;
        front=(front+1)%elements.length;
        return retdata;
    }
}

public Object peek()
{
    if (isEmpty())
    {
        System.out.println("Queue is empty");
        return null;
    }
    else
    {
        return elements[front];
    }
}

public boolean isEmpty()
{
    return elements[front]==null;
}

public boolean isFull()
{
    return (front==(rear+1)%elements.length&&elements[front]!=null&&elements[rear]!=null);
}

public int size()
{
    if (elements[front]==null)
    {
        return 0;
    }
    else
    {
        if (rear>=front)
        {
            return rear-front+1;
        }
        else
        {
            return elements.length-(front-rear)+1;
        }
    }
}

}