Pesquisa predicada em java

Question

Não tenho certeza de como dizer essa pergunta. Gostaria de saber se existe um método para verificar certas partes de uma classe Java personalizada para ver se ela corresponde a determinados critérios. Tal como este

public Name(String forename, String middlename, String surname)

E então quando uma variedade de instâncias dessa classe são criadas, digamos,

Name[] applicants = new Name[4];

applicants[0] = new Name("john","bob", "rush");
applicants[1] = new Name("joe","bob", "rushden");
applicants[2] = new Name("jack","bob", "rushden");
applicants[3] = new Name("jake","bob", "rushden");

É possível fazer uma pesquisa nas instâncias da classe para pessoa com

midddlename.equals("bob") && surname.equals("rush")

Eu realmente não estou procurando uma solução que seja if(surname.equals("bob")) then else, etc.

Mas mais uma aula de java embutida que permite pesquisas rápidas sobre a matriz. A velocidade disso é muito importante.

Answer 1

Não há suporte de apoio, mas Coleções Apache e Coleções do Google Ambos fornecem suporte predicado sobre coleções.

Você pode encontrar essa questão e suas respostas úteis. O mesmo com isso desenvolvedor.com artigo.

por exemplo, usando o Google Collections:

final Predicate<name> bobRushPredicate = new Predicate<name>() {
   public boolean apply(name n) {
      return "bob".equals(n.getMiddlename()) && "rush".equal(n.getSurname());
   }
}

final List<name> results = Iterables.filter(applicants, bobRushPredicate));

Answer 2

Pesquisando através de uma matriz e "a velocidade é muito importante" não se juntam. A menos que sua matriz seja muito pequena, pesquisar uma matriz nunca será rápida. Este é o equivalente a uma varredura de tabela completa em um banco de dados, o desempenho, não importa como você o faça, será ruim. A chave para encontrar as coisas rapidamente é usar uma estrutura indexada. Você ainda pode ter uma matriz se precisar, mas a pesquisa deve ser feita usando outra estrutura de dados. Confira uma coleção baseada em hash ou árvore, pois organizam dados de uma maneira que o torne muito rápido de recuperar. TreeSet, Treemap, Hashset, Hashmap, etc. Os dados do índice de hashes em uma chave de hash, as árvores são semelhantes, mas também armazenam seus dados em uma ordem classificada.

Answer 3

Se você precisar pesquisar com base na igualdade de objeto sobre a verificação da matriz apache common ArrayUtils, Você basicamente precisa substituir seus iguais e hascode para o objeto de nome e usá -lo, mas se você quiser usar critérios de pesquisa personalizados, acho que precisa implementar seu próprio caminho e não há suporte de idioma Java

Answer 4

Use um banco de dados de memória como Apache Derby ou HSQLDB. Aproveite JDBC, JPA ou Hibernate, que podem fazer o que você deseja.

Perfil seu código. Depois otimize.

Answer 5

A maneira mais rápida de pensar é criar uma estrutura de dados que reflete esses objetos de valores de propriedades e mantenha o índice interno para cada valor.

Quando um valor é pesquisado, essa estrutura de dados interna retornará o índice usando a pesquisa binária.

O único requisito é que seu objeto deve registrar e atualizar essa estrutura.

Algo como o seguinte Código Imaginário UML/Python:

 // Holds the index number of a given value
 // for instance, name="Oscar" may be at index 42...
 IndexValuePair
     index : Int
     value : String 

     +_ new( value: String, index: Int ) 
          return IndexValuePair( value, index )

 ValuePairComparator --> Comparator 

     + compareTo( a: IndexValuePair, b: IndexValuePair ) : Int 

         return a.value.compareTo( b.value )

 SearchStructure
     - data = Object[] // The original array which contains your applicants
      // a list of arrays each one containing the property value, and the index on "data" where that value appears 
     - dataIndexes =  List(IndexValuePair)[String] // Map<List<IndexValuePair>> 
     - dataIndexexInitialized = false

     // Add an object to this structure
     + addObject( o: Object ) 
          if( ! dataIndexesInitialized, 
              initIndexesWith( o )
          )

          index = data.add( o ) // returns the index at which "o" was inserted
          addToIndexes( o, index ) 

     // Register all the properties values of the given object 
     // along with the index where they appear in the original array 
     - addToIndexes( object: Object, index: Int ) 
           forEach( property in Object , 
              list = dataIndexes[property]
              list.add( IndexValuePair.new( property.value, index ) ) 
           )
     // Create empty array for each property .. 
     - initIndexesWith( object : Object ) 
          forEach( property in object , 
                comparator = ValuePairComparator()
                list = List<IndexValuePair>()
                list.setComparator(  ) 
                dataIndexes[property] =  list
          )
          dataIndexesInitialized = true 


     // Search an object using the given criteria ( a Map<String, String> = key=value ) 
     + search( criteria: String[String] ) : List<Object>

        result = Set<Object>()

        // let's say criteria has:
        // ["name":"Oscar", "lastName"="Reyes"]
       forEach( key in criteria, 
            list = dataIndexes[key]  // "name", "lastname" ..etc. 
            valuePair = list.binarySearch( criteria[key] ) // first Oscar, later Reyes 
            result.add( data[valuePair.index] )
       ) 

       return result

Opa

Espero que isso seja compreensível.

O ponto é que, se você realmente tem isso muito rápido, precisa manter os índices por propriedade

1. Uma matriz para os dados
2. Uma matriz para cada propriedade, que por sua vez teria o índice de dados

Por exemplo, se você tiver a seguinte matriz:

 a = [ Object(name="Mike", lastName="Z" )
       Object(name="Oscar", lastName="Reyes" ) , 
       Object(name="Rahul", lastName="G" ) , 
       Object(name="Pie", lastName="154" )  ]

Eles teriam as posições:

0 = Mike ... 
1 = Oscar ...
2 = Rahul ...
3 = Pie ...

E você terá duas matrizes separadas (neste caso) que, depois de serem classificadas, seriam:

nameArray =  ["Mike=0", "Oscar=1", "Pie=3", "Rahul=2"]

e

lastNameArray =   ["154=3", "G=2", "Reyes=1", "Z=0"]

Ao procurar um determinado atributo, você pega a matriz correspondente, por exemplo, se você for para pesquisar o sobrenome "Reyes" você tomará "LastName" Array

 ["154=3", "G=2", "Reyes=1", "Z=0"]

E executará o BininarySearch para "Reyes", que retornará o elemento na posição 2, que por sua vez retornará o índice = 1 whih é a posição "Oscar" tem na matriz original.

Isso deve manter as coisas em O (log n)

Answer 6

Acontece que entre outros bugs, às vezes a propriedade Torm.Stylebook não é automaticamente atribuída.Se você verifique se ele é atribuído, as etapas acima funcionam.

passos rápidos:

.
1. criar forma.
2. Livro de estilo de queda no formulário, e atribuir formulário.stylebook= StyleBook1
3. Clique com o botão direito do mouse no controle que você deseja modificar o estilo, clique em Editar estilo personalizado.
4. Vá para o inspetor de objetos e modifique a propriedade Preenchimento para alterar a cor do fundo do painel, por exemplo.
5. Aplicar e fechar.(Pode ter que clicar em dois, três ou quatro vezes devido a bugs de foco da janela)

   

   Nota: Esta solução não é útil no Delphi XE4 e no recurso "Configuração de estilo personalizado" foi removida do aplicativo móvel FMX.

Answer 7

O Java 8 adicionou expressões Lambda e a API do fluxo, então o suporte está embutido agora.

Name[] applicants = new Name[4];

applicants[0] = new Name("john", "bob", "rush");
applicants[1] = new Name("joe", "bob", "rushden");
applicants[2] = new Name("jack", "bob", "rushden");
applicants[3] = new Name("jake", "bob", "rushden");

Optional<Name> result = Arrays.stream(applicants)
    .filter(name -> name.middlename.equals("bob") && name.surname.equals("rush"))
    .findAny();

result.ifPresent(name -> System.out.println(name));

Existem muitas opções disponíveis aqui. Você pode obter o primeiro nome a combinar com a troca .findAny() para .findFirst() ou execute a pesquisa em paralelo, inserindo .parallel() depois .stream(applicants), por exemplo.