Ajuda com ordenação complexa? (Collections.sort()) [RESOLVIDO]

Programação Java
#1

Boa tarde!

Estou com o seguinte problema:
Tenho que ordenar itens de uma lista com base em múltiplos critérios ordenados.

Tenho a classe (entidade) abaixo que define a priorização, salva numa tabela do banco:

public class Prioridade
{

    private String nomePrioridade;
    /**
     * Se esta prioridade está ativa ou não
     */
    private boolean ativo;
    /**
     * Contém os valores que serão priorizados e sua respectiva ordem
     */
    private TreeMap<Byte, String> mapaValores;
}

Representação no BD:
nomePrioridade campos usados no mapa - valor e ordem ativo
Método de Pagamento ; DD; 1; 1
Regional; SP; 1; 1
Regional; BA; 2; 1

Preciso ordenar objetos da classe abaixo - armazenados em um List

public class FaturaDevolvida
        implements Serializable {

    private static final long serialVersionUID = 1L;
    private int identificao;
    private Long numeroConta;
    private String fornecedor;
    private String motivoDevolucao;
    private String metodo_Pagto;

Tenho 5 níveis de priorização:
Nos primeiros três deles, tenho que ordenar a lista conforme valores de alguns campos dos objetos - que comparo com valores do mapa da classe Prioridade.
Nos últimos, tenho que ordenar conforme o valor de alguns campos em ordem ascendente ou descrescente.

Os últimos níveis de priorização eu poderia fazer até no código SQL, mas são tantos os níveis que está ficando muito difícil…

Criei então uma classe que implementa Comparator:

    private class ComparadorMetodoPagamento implements Comparator {

        private TreeMap<Byte, String> mapaPriorizacao;

        public ComparadorMetodoPagamento(TreeMap<Byte, String> mapaPriorizacao) {
            setMapaPriorizacao(mapaPriorizacao);
        }

        private TreeMap<Byte, String> getMapaPriorizacao() {
            return mapaPriorizacao;
        }

        private void setMapaPriorizacao(TreeMap<Byte, String> mapaPriorizacao) {
            this.mapaPriorizacao = mapaPriorizacao;
        }

        public int compare(Object obj1, Object obj2) {
            int retorno = 0;
            if (obj1 == null || obj2 == null) {
                return 0;
            }

            FaturaDevolvida objeto1 = (FaturaDevolvida) obj1;
            FaturaDevolvida objeto2 = (FaturaDevolvida) obj2;

            for (Byte ordem : getMapaPriorizacao().keySet()) {
                if (objeto1.getMetodo_Pagto().equals(getMapaPriorizacao().get(ordem))
                        && objeto2.getMetodo_Pagto().equals(getMapaPriorizacao().get(ordem))) {
                    retorno = 0;
                } else if (objeto1.getMetodo_Pagto().equals(getMapaPriorizacao().get(ordem))
                        && !objeto2.getMetodo_Pagto().equals(getMapaPriorizacao().get(ordem))) {
                    retorno = 1;
                } else {
                    retorno = -1;
                }
            }
            return retorno;
        }
    }

Bom, o que eu estou tentando fazer então:

 //1 - Instancio a lista e a alimento
 List<FaturaDevolvida> listaFaturas = new ArrayList <FaturaDevolvida> ();
 while (resultSet.next()) {
     //... alimentando lista
 }

//2 - Recupero todos os 5 níveis de priorização do BD
  //recuperando informações de prioridades
  PrioridadeMailingDAO prioridadeDAO =
                    new PrioridadeMailingDAO(getDadosAcessoBD());
  List<PrioridadeMailing> prioridades =
                    prioridadeDAO.getListaPrioridadeMailing();


//3 - Recupero o primeiro nível de priorização - se conseguir fechar esse, faço para os demais objetos de Prioridade
           PrioridadeMailing priori = null;
            for (PrioridadeMailing prioriI : prioridades)
            {
                if (prioriI.getNomePrioridade().equals("Método de Pagamento"))
                {
                    priori = prioriI;
                    break;
                }
            }

//4 - Utilizo o sort propriamente dito
            ComparadorMetodoPagamento comparador =
                    new ComparadorMetodoPagamento(priori.getMapaValores());
            Collections.sort(listaFaturas, comparador);

O grande problema é que não está ordenando corretamente. Como posso proceder?

#2

Se não está ordenando certo então investigue seu método compare no seu Comparator

#3

Consegui fazer a ordenação por lista de valores.
Resolvi mapear e atribuir um valor de prioridade para cada valor que quero priorizar.
Daí verifico se o valor da prioridade do atributo do objeto 1 á maior que o valor da prioridade do atributo do objeto 2.

Como eu faço a ordenação por vários atributos em uma sequência determinada (ex.: ordenar por estado cívil, depois por idade, depois por profissão, etc…), eu recupero o atriburo que quero ordenar através de um método onde passo um parâmetro indicando qual atributo eu quero:

String atribObjeto1 = objeto1.getAtributoOrdenavel(getPrioridade().getNomePrioridade());
        private final static int SEM_ACAO_EXECUTAR = 0;
        private final static int MAIOR = 1;
        private final static int MENOR = -1;
        private PrioridadeMailing prioridade;
        private Map<String, Byte> mapaPriorizacao;

        public ComparadorParaListaPrioridade(
                PrioridadeMailing prioridade)
                throws Exception {

            setPrioridade(prioridade);
            mapaPriorizacao =
                    MapUtils.inverse(getPrioridade().getMapaValores());

        }


        @Override
        public int compare(Object obj1, Object obj2) {

            //Se a prioridade está inativa, retorna 0 e não faz nenhuma mudança
            if (!getPrioridade().isAtivo()) {
                return SEM_ACAO_EXECUTAR;
            }

            // ** Validar este trecho depois ...
            // Se um dos objetos comparados for nulo, retorna 0
            if (obj1 == null && obj2 == null) {
                return SEM_ACAO_EXECUTAR;
            } else if (obj1 != null && obj2 == null) {
                return MAIOR;
            } else if (obj1 == null && obj2 != null) {
                return MENOR;
            }


            //Instanciando objetos e recuperando mapa com a ordem de prioridade dos mesmos
            FaturaDevolvida objeto1 = (FaturaDevolvida) obj1;
            FaturaDevolvida objeto2 = (FaturaDevolvida) obj2;

            //Recuperando os atributos que serão avaliados para ordenar a lista de objetos
            String atribObjeto1 = objeto1.getAtributoOrdenavel(getPrioridade().getNomePrioridade());
            String atribObjeto2 = objeto2.getAtributoOrdenavel(getPrioridade().getNomePrioridade());


            Byte ordemObjeto1 = mapaPriorizacao.get(  (atribObjeto1 != null ? atribObjeto1.trim() : null )  );
            Byte ordemObjeto2 = mapaPriorizacao.get(  (atribObjeto2 != null ? atribObjeto2.trim() : null )  );

            //Primeiras condicionais testam se há índices nulos entre os valores
            //se houverem
            if (ordemObjeto1 == null && ordemObjeto2 == null) {
                return SEM_ACAO_EXECUTAR;
            } else if ((ordemObjeto1 != null && ordemObjeto1 >= 1) && ordemObjeto2 == null) {
                return MENOR;
            } else if (ordemObjeto1 == null && (ordemObjeto2 != null && ordemObjeto2 >= 1)) {
                return MAIOR;
            } else {

                if (ordemObjeto1 == ordemObjeto2) {
                    return SEM_ACAO_EXECUTAR;

                } else if (ordemObjeto1 < ordemObjeto2) {
                    return MENOR;

                } else {
                    return MAIOR;
                }
            }   //fim dos blocos if de comparação de nulos

        }       //fim do método compare

Grato!

#4

Altera o titulo para [RESOLVIDO]

#5