Comparator Dinâmico[RESOLVIDO]

Programação Java
#1

Boa tarde,

Gostaria de implementar um Camparator Dinâmico. Isso é possível?

O getFiltro1 cada hora vai ser um fitro diferente conforme escolhido pelo usuário.

return = Obj1.getFiltro1().compareTo(Obj1.geFiltro1());

Obrigada

#2

Este código, no mínimo, vai ficar difícil de ser compreendido, detalhe o que necessita para que seja mais fácil ajudar.

#3

o código que voce fez usa compareTo, que é de Comparable. o Comparable não é mto indicado para fazer comparadores dinamicos. mas aí tem o Comparator (com metodo compare apenas) que é indicado pra isso.

recomendo esse artigo sobre o assunto:
http://blog.caelum.com.br/2010/06/22/ordenando-colecoes-com-comparable-e-comparator/

#4

Eu usuario o padrão decorator para resolver esse problema.

#5

Esse codigo ordena conforme o case escolhido:
Case1 = nome
Case2 = nome e cidade
Preciso fazer uma implementação onde usuário escolhe assim:
Quero fazer uma ordenação por cidade… ai entra no case1
Quero fazer uma ordenação por nome… ai entra no case1
Quero fazer uma ordenação por cidade e nome… ai entra no case2
No meu código a ordenação está fixa. Gostaria de tornar isso dinâmico assim:
case 2:
retorno = emp1.getPrimeiroParametro().compareTo(emp2.getPrimeiroParametro());
if (retorno != 0) return retorno;
retorno = emp1.getSegundoParametro().compareTo(emp2.getSegundoParametro());
break;

Abaixo segue o código atual…

class teste{   
    String nome;   
    String cidade;   
    String prof;   
    public teste(String c, String p, String n) {   
       nome = n; cidade = c; prof = p;   
    }   
    public String toString() {   
        return cidade + " - " + prof + "  - " + nome;   
    }   
    public String getcidade() {
        return cidade;
      }
    public String getprof() {
        return prof;
      }
    public String getnome() {
          return nome;
        }
}   
class Person implements  Comparator<teste>  
   {  
	int qtparametros = 3;
	public int compare(testeemp1, testeemp2) { 
	          		  int retorno = 0;  
	          		  
	          		  switch (this.qtparametros) {  
	                     case 1:  
	                        retorno = emp1.getnome().compareTo(emp2.getnome());  
	                         break;  
	                     case 2:  
	                    	 retorno = emp1.getcidade().compareTo(emp2.getcidade()); 
	                    	 if (retorno != 0) return retorno;
	                    	 retorno = emp1.getnome().compareTo(emp2.getnome());  
	                    	 break;
	             	        default:  
	                         throw new RuntimeException("opcao invalida");  
	                   }  
	                return retorno;  
	                } 
	           }

Obrigada

#6

Você pode utilizar polimorfismo junto com o padrão Decorator http://en.wikipedia.org/wiki/Decorator_pattern que consiste em criar uma cadeia de operações, desta forma:

class Teste {
  private String nome;
  private String cidade;
  // getters e setters
}

abstract class ComparadorDecorado implements Comparator<Teste> {

  private ComparadorDecorado proximo;

  public ComparadorDecorado(ComparadorDecorado proximo) {
    this.proximo = proximo;
  }

  public int compare(Teste t1, Teste t2) {
    int resultado = doCompare(t1, t2);
    if (resultado == 0 && this.proximo != null) { // o primeiro filtro não é suficiente, passamos para o próximo se existir
      resultado = this.proximo.compare(t1, t2);
    }
    return resultado;
  }

  public abstract int doCompare(Teste t1, Teste t2);
}

class ComparadorDecoradorNome extends ComparadorDecorado {
  
  // construtor

  public int doCompare(Teste t1, Teste t2) {
    // não estou testando nulos para ficar um código menor
    return t1.getNome().compareTo(t2.getNome());
  }

}

class ComparadorDecoradorCidade extends ComparadorDecorado {
  
  // construtor

  public int doCompare(Teste t1, Teste t2) {
    // não estou testando nulos para ficar um código menor
    return t1.getCidade().compareTo(t2.getCidade());
  }

}

// pode usar da seguinte forma

new ComparadorDecoradorNome(null); // só para nome
new ComparadorDecoradorCidade(null); // só para cidade
new ComparadorDecoradorNome(new ComparadorDecoradorCidade()); // para nome e cidade, respectivamente

não compilei o código, me desculpe se houver algum erro.

#7

Acho q não me antende.
Vou ter mais de 18 filtros que o usuário pode escolher.
Aqui vc passou por nome, cidade, nome e cidade… a ordem é dinâmica.
Vou especificar melhor…
Atributos
-nome
-cidade
-profissao
-cpf

O usuario pode fazer várias combinações

nome + cidade
nome + profissao
nome + cpf
cpf+ nome + cidade + prof
nome
cidade + nome
e ai vai…

Obrigada

#8

Digamos que você possua uma lista de chaves do tipo String selecionadas pelo usuário, via algum controle de seleção múltipla como checkboxes.

A idéia por trás do decorator é percorrer essa lista de trás para frente, decorando o Comparator final de forma que não seja necessário fazer muitos testes, exemplo:



ComparadorDecorado criaComparador(String opcao, ComparadorDecorado proximo) {

  if (opcao.equals("nome") {
    return new ComparadorDecoradoNome(proximo);
  } else if (opcao.equals("cidade")) {
    return new ComparadorDecoradoCidade(proximo);
  } 

  ...
  ...

}


List<String> opcoes = ...; // construído a partir da interface visual, na ordem inversa de importância

ComparadorDecorado comparador = null;
for (String opcao : opcoes) {
  comparador = criaComparador(opcao, comparador);
}

// aqui vc possui uma instância de comparador dinâmica, de acordo com as escolhas do usuário
#9