Búsqueda predicado en Java

Question

No estoy seguro de cómo formular esta pregunta. Me pregunto si hay un método para comprobar ciertas partes de una clase Java personalizada para ver si coincide con un cierto criterio. Como este

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

Y luego, cuando un conjunto de instancias de esa clase se crean por ejemplo,

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");

¿Es posible hacer una búsqueda sobre las instancias de la clase de persona con

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

No estoy realmente buscando una solución que es if(surname.equals("bob")) then else, etc.

Sin embargo, más de una clase Java incorporado que permite una rápida búsqueda sobre la matriz. la velocidad de esto es muy importante.

Answer 1

No se construye en apoyo, pero Apache Colecciones y Google Colecciones ambos proporcionan apoyo predicado sobre colecciones.

Usted puede encontrar esta pregunta y sus respuestas útiles. Lo mismo pasa con este developer.com artículo.

por ejemplo. Uso de Google Colecciones:

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

Buscando a través de una matriz y "la velocidad es muy importante" en realidad no ir juntos. A menos que si la matriz será muy pequeño, entonces buscar a través de una matriz nunca será rápida. Este es el equivalente de un escaneo completo de tabla en una base de datos, el rendimiento no importa cómo usted va sobre él será pobre. La clave para encontrar las cosas rápidamente es utilizar una estructura indexada. Usted todavía puede tener una matriz si usted lo necesita absolutamente pero la búsqueda se debe hacer uso de otra estructura de datos. ¿Quieres crear un hash o una colección basada en árbol, ya que organizan los datos de una manera que lo hacen muy rápido a recuperar. TreeSet, TreeMap, HashSet, HashMap, etc. Los valores hash de datos de índice en una clave hash, los árboles son similares, pero también almacenan sus datos en una forma ordenada.

Answer 3

Si es necesario buscar en base a la igualdad de objetos sobre verificación gama apache common ArrayUtils, que básicamente tienen que reemplazar sus iguales y hascode de nombre del objeto y usarlo, pero si desea utilizar la costumbre criterios de búsqueda, yo supongo que hay que poner en práctica su propio camino y no hay ninguna está construido en el soporte del lenguaje java

Answer 4

El uso de una base de datos en la memoria como Apache Derby o hsqldb . Tome ventaja de JDBC, JPA, Hibernate o, todo lo cual puede hacer lo que quiera.

perfil de su código. Entonces Optimizar.

Answer 5

La forma más rápida que puedo pensar, es crear una estructura de datos que esta espejos objetos valores de la propiedad y mantener el índice interno para cada valor tiene.

Cuando se busca un valor, esta estructura de datos interna devolverá el índice mediante la búsqueda binaria.

El único requisito es que su objeto debe registrar y actualizar esta estructura.

Algo parecido a lo siguiente UML imaginaria / Python como el código:

 // 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

Vaya

Espero que esto es comprensible.

El punto es, si realmente lo que debe tener este muy rápido, usted tiene que mantener los índices de la propiedad

1. Una matriz para los datos
2. Una matriz para cada propiedad, que a su vez tendría el índice de los datos

Por ejemplo, si usted tiene la siguiente matriz:

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

Se tendría las posiciones:

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

Y tendrá dos (en este caso) matrices separadas que después de haber sido ordenados sería:

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

y

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

Cuando se busca un atributo dado, se toma la matriz correspondiente, por ejemplo, si Wan para buscar el apellido "Reyes" que va a tomar "Apellido" array

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

y llevará a cabo binarySearch en ella para "Reyes" que devolverá el elemento en la posición 2, que a su vez devolverá el índice = 1 whih es la posición "Oscar" tiene en la matriz original.

Esto debe mantener las cosas bajo O (log n)

Answer 6

Mira clase ParallelArray, satisface sus necesidades, pero hay que aprender un poco de los conceptos de programación funcionales a utilizar de manera eficiente.

La clase no viene con el JDK 6, pero podría venir con JDK 7 (en discusión). Mientras tanto se puede usar como una biblioteca - descargar el paquete JSR166y de: http://gee.cs.oswego.edu/dl/concurrency-interest/

Consulte este tutorial para obtener una explicación detallada: http://www.ibm.com/developerworks/java/library/ j-jtp03048.html

Puede sonar complicado y es (si arew acaba de cavar en los algoritmos de alto rendimiento multi-hilo). Hay un proyecto maravilloso que trata de envolver un API más fácil de usar alrededor de conjunto en paralelo, por lo que es posible que desee ttake una mirada en ella, así: http://gpars.codehaus.org/ , http: // GPars. codehaus.org/Parallelizer

Answer 7

Java 8 añadido expresiones lambda y la API de corriente, por lo que el apoyo está integrado en este momento.

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));

Hay un montón de opciones disponibles aquí. Usted puede obtener el primer nombre que coincida cambiando .findAny() a .findFirst() o ejecutar la búsqueda en paralelo mediante la inserción de .parallel() después .stream(applicants), por ejemplo.