/* ************************************************************ */
public List pesquisarEntreValores(
List resultadoDaPesquisa,
String nomeAtributoComparado,
Comparator comparadorAtributo,
Object valorInicial,
Object valorFinal) {
if (resultadoDaPesquisa != null) {
// Configura o método get para obter os valores comparados
String nomeMetodo =
"get"
+ nomeAtributoComparado.substring(0, 1).toUpperCase()
+ nomeAtributoComparado.substring(1, nomeAtributoComparado.length());
// Ordena o resultado da pesquisa em ordem crescente dos valores do
// atributo comparado:
List resultado = new ArrayList();
resultado.addAll(resultadoDaPesquisa);
Util.ordenarObjetos(resultado, comparadorAtributo);
// Isola o conjunto de valores do atributo comparado em uma lista de
// valores, que tem a mesma ordenação e tamanho da lista de objetos
// do resultado da pesquisa:
List valoresAtributoComparado = new ArrayList();
for (int i = 0; i < resultado.size(); i++) {
valoresAtributoComparado.add(Util.executarMetodo(resultado.get(i), nomeMetodo, null));
}
// Da lista de valores, recupera o primeiro que seja maior ou igual
// a valorInicial:
int indiceValorInicial = Collections.binarySearch(valoresAtributoComparado, valorInicial);
if (indiceValorInicial < 0) {
indiceValorInicial = -(indiceValorInicial + 1);
}
// Da lista de valores, recupera o último que seja menor ou igual a
// valorFinal:
int indiceValorFinal = Collections.binarySearch(valoresAtributoComparado, valorFinal);
if (indiceValorFinal < 0) {
indiceValorFinal = -(indiceValorFinal + 1);
} else {
indiceValorFinal++;
}
// Recupera os objetos entre indiceValorInicial e indiceValorFinal:
resultado = resultado.subList(indiceValorInicial, indiceValorFinal);
// Retorna os objetos que satisfazem aos critérios, caso existam
if (resultado.size() > 0) {
return resultado;
}
}
return null;
}
/**
* Dado o resultado da pesquisa decorrente da chamada a 'pesquisar(...)' ou
* 'pesquisarOrdenado(...)', retorna o conjunto de valores distintos de um determinado atributo
* dos objetos pesquisados.
*
* @param resultadoDaPesquisa o resultado da pesquisa decorrente da chamada a 'pesquisar(...)' ou
* 'pesquisarOrdenado(...)'.
* @param nomeAtributoDistinto o nome do atributo do qual se deseja recuperar os valores distintos
* @return conjunto de valores distintos do atributo especificado dos objetos retornados pela
* pesquisa @
*/
public List pesquisarValoresDistintos(List resultadoDaPesquisa, String nomeAtributoDistinto) {
if (resultadoDaPesquisa != null) {
// Configura o método get para obter os valores distintos
String nomeMetodo =
"get"
+ nomeAtributoDistinto.substring(0, 1).toUpperCase()
+ nomeAtributoDistinto.substring(1, nomeAtributoDistinto.length());
// Recupera o conjunto de valores distintos do atributo
List valoresDistintos = new ArrayList();
for (int i = 0; i < resultadoDaPesquisa.size(); i++) {
Object valorDistinto = Util.executarMetodo(resultadoDaPesquisa.get(i), nomeMetodo, null);
if (!valoresDistintos.contains(valorDistinto)) {
valoresDistintos.add(valorDistinto);
}
}
// Retorna os valores satisfazem aos critérios, caso existam
if (valoresDistintos.size() > 0) {
return valoresDistintos;
}
}
return null;
}
/**
* Dado o resultado da pesquisa decorrente da chamada a 'pesquisar(...)' ou
* 'pesquisarOrdenado(...)', retorna todos os objetos cujo valor do atributo comparado seja igual
* ao conjunto de valores informados para o atributo.
*
* @param resultadoDaPesquisa o resultado da pesquisa decorrente da chamada a 'pesquisar(...)' ou
* 'pesquisarOrdenado(...)'.
* @param nomeAtributoComparado o atributo que será utilizado para filtrar os objetos que possuem
* valor igual aos valores informados
* @param comparadorAtributo comparador capaz de comparar valores distintos de um dado atributo de
* um tipo de objeto
* @param valores os valores do atributo comparado
* @return os objetos cujo valor do atributo comparado seja igual ao conjunto de valores
* informados, ou null caso não existam objetos que satisfaçam a esses critérios @
*/
public List pesquisarValores(
List resultadoDaPesquisa,
String nomeAtributoComparado,
Comparator comparadorAtributo,
List valores) {
if (resultadoDaPesquisa != null) {
List resultado = new ArrayList();
// Configura o método get para obter os valores comparados
String nomeMetodo =
"get"
+ nomeAtributoComparado.substring(0, 1).toUpperCase()
+ nomeAtributoComparado.substring(1, nomeAtributoComparado.length());
// Recupera os objetos do resultado da pesquisa cujo valor do
// atributo esteja contido no conjunto de valores desejados:
for (int i = 0; i < resultadoDaPesquisa.size(); i++) {
if (valores.contains(Util.executarMetodo(resultadoDaPesquisa.get(i), nomeMetodo, null))) {
resultado.add(resultadoDaPesquisa.get(i));
}
}
// Retorna os objetos que satisfazem aos critérios, caso existam
if (resultado.size() > 0) {
return resultado;
}
}
return null;
}
/**
* Dado o resultado da pesquisa decorrente da chamada a 'pesquisar(...)' ou
* 'pesquisarOrdenado(...)', e um objeto pertencente ao resultado dessa pesquisa, retorna o objeto
* posterior.
*
* @param resultadoDaPesquisa o resultado da pesquisa decorrente da chamada a 'pesquisar(...)' ou
* 'pesquisarOrdenado(...)'.
* @param objetoAtual o objeto de referência para recuperação do objeto posterior
* @return o objeto constante da lista na posição posterior ao do objeto informado @
*/
public Object pesquisarProximoObjeto(List resultadoDaPesquisa, Object objetoAtual) {
if (resultadoDaPesquisa != null && resultadoDaPesquisa.size() > 0 && objetoAtual != null) {
if (resultadoDaPesquisa.get(0).getClass().equals(objetoAtual.getClass())) {
Util.ordenarObjetos(resultadoDaPesquisa);
int posicaoProximoObjeto = resultadoDaPesquisa.indexOf(objetoAtual) + 1;
if (resultadoDaPesquisa.size() > posicaoProximoObjeto) {
return resultadoDaPesquisa.get(posicaoProximoObjeto);
}
} else {
throw new RuntimeException(
"[pesquisarProximoObjeto] tipo do objeto diferente do tipo da lista.");
}
}
return null;
}