/* ************************************************************ */
  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;
 }