Ordenar cartas en Java

import java.util.Scanner;


public class Main{

/**
* @param args
*/
public static void main(String[] args) {
// 1. Leer todas las cartas, crear los objetos Carta asociados y almacenarlos.
Carta[] cartasleidas = leerCartas();

// 2. Eliminar las cartas repetidas
Carta[] cartasNoRepes = eliminarCartasRepetidas(cartasleidas);

// 3. Ordenar las cartas por palo y numero
ordenarCartasPorPaloYNumero(cartasNoRepes);

// 4. Imprimir las cartas
imprimirCartas(cartasNoRepes);

}

private static void imprimirCartas(Carta[] cartasNoRepes) {
if (cartasNoRepes.length > 0)
System.out.print(cartasNoRepes[0]);

for (int i=1; i < cartasNoRepes.length; i++)
System.out.print(" " + cartasNoRepes[i]);

System.out.println();
}

private static void ordenarCartasPorPaloYNumero(Carta[] nums) {
for (int i=1; i < nums.length; i++)
for (int j=nums.length-1; j >= i; j--){
if ( nums[j-1].calculaMenorOIgual(nums[j]) == nums[j] ) {
Carta aux = nums[j-1];
nums[j-1] = nums[j];
nums[j] = aux;
}
}
}

private static Carta[] eliminarCartasRepetidas(Carta[] cartasleidas) {
int[] aux = new int[10]; // almacena el número de cartas que tienen el número asociado a la posición+1,
for (int i=0; i<cartasleidas.length; i++){
aux[cartasleidas[i].getNumero().ordinal()] += 1;
}
int ndist = 0; //el número de cartas distintas.

for (int i = 0; i< aux.length; i++)
if (aux[i] == 1)
ndist+=1;

Carta[] result = new Carta[ndist];
for (int i=0, j=0; i<cartasleidas.length; i++){
if (aux[cartasleidas[i].getNumero().ordinal()] == 1){
result[j++] = cartasleidas[i];
}
}

return result;
}
/** Leer las cadenas de la entrada estándar, crear los objetos Carta asociados y
* almacenarlos en un array.
* @return devueve el array con los objetos de tipo Carta creados a partir de la entrada
*/
private static Carta[] leerCartas() {
final int MAXNCARTAS = Integer.MAX_VALUE; //10;
Scanner lee = new Scanner(System.in);
Carta[] cartas = new Carta[MAXNCARTAS];
int ncartas = 0; // El número de cartas leído.
while (ncartas < MAXNCARTAS && lee.hasNext())
cartas[ncartas++] = new Carta(lee.next());
if (ncartas == MAXNCARTAS)
return cartas;
Carta[] aux = new Carta[ncartas];
for (int i = 0; i < ncartas; i++)
aux[i] = cartas[i];
return aux;
}

}

/** Los objetos de la clase Carta modelizan cartas tradicionales de la baraja española, sin
incluir ochos y nueves.
*/
 class Carta{

/** Atributo que almacena el palo de la carta.*/
private PaloCarta palo;

/** Atributo que almacena el número de la carta.*/
private NumeroCarta numero;

/** Constructor que crea una carta con el número y palo dados.

@param n Un número válido de una carta de la baraja española.
@param p Un palo válido de la baraja española.
*/
public Carta( NumeroCarta n, PaloCarta p){
   numero = n; palo = p;

   }


public Carta(String next) {
switch (next.charAt(next.length()-1)){
case 'o': palo = PaloCarta.OROS;break;
case 'c': palo = PaloCarta.COPAS;break;
case 'e': palo = PaloCarta.ESPADAS;break;
case 'b': palo = PaloCarta.BASTOS;break;
}

if (next.length() == 2)
numero = NumeroCarta.values()[Character.digit(next.charAt(0), 10) - 1];
else
numero = NumeroCarta.values()[Integer.parseInt(next.substring(0, 2))-3];
}


/** Devuelve el palo de la carta.
@return El palo de la carta.
*/
public PaloCarta getPalo() {return palo;}

/** Devuelve el número de la carta.
@return El palo de la carta.
*/
public NumeroCarta getNumero() {return numero;}

/** Fija el palo de la carta.

@param p Un palo válido de la baraja española.
*/
public void setPalo(PaloCarta p){
        palo = p;
}
/** Fija el número de la carta.

@param n Un número válido de la baraja española.
*/
public void setNumero(NumeroCarta n) {
        numero = n;
    }

/** Método que devuelve una cadena con el palo de la carta.
 */
public String nombrePalo (){
switch (palo){
case OROS: return "o";
case COPAS: return "c";
case ESPADAS: return "e";
case BASTOS: return "b";
}
return ""; //Para la queja del compilador
}

/** Método que devuelve una cadena con el numero de la carta.
 */
public String nombreNumero (){
switch (numero){
case AS: return "1";
case DOS: return "2";
case TRES: return "3";
case CUATRO: return "4";
case CINCO: return "5";
case SEIS: return "6";
case SIETE: return "7";
case SOTA: return "10";
case CABALLO: return "11";
case REY: return "12";
}
return ""; //Para la queja del compilador
}

/** Método de ordenación de dos cartas. Permite saber si la carta
actual es menor o igual que la carta pasada como argumento. El
orden usado es el clásico en las cartas españolas: primero ordenar
por palos (OROS < COPAS < ESPADAS < BASTOS) y dentro del palo
ordenar por números (AS < DOS < ... < SOTA < CABALLO < REY)

@param carta  la carta a comparar con la carta actual.
@return la carta menor entre la carta actual y la carta pasada
como argumento.
 */
public Carta calculaMenorOIgual(Carta carta){
        if (palo.ordinal() < carta.palo.ordinal())
return this;
        if (carta.palo.ordinal() < palo.ordinal())
return carta;
        if (numero.ordinal() < carta.numero.ordinal())
return this;
        if (carta.numero.ordinal() < numero.ordinal())
return carta;
return this;
}

@Override
public String toString (){

return nombreNumero() + nombrePalo();
}
}

 enum PaloCarta {OROS, COPAS, ESPADAS, BASTOS}
 enum NumeroCarta {AS, DOS, TRES, CUATRO, CINCO, SEIS, SIETE, SOTA, CABALLO, REY}