Prädikat Suche in Java

Gibt es nicht errichtet in der Unterstützung, aber Apache-Sammlungen und Google Collections beide bieten Prädikat Unterstützung über die Sammlungen.

Können Sie finden diese Frage und deren Antworten hilfreich sind. Das gleiche mit dieser developer.com Artikel.

z.B. Mit 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));

Wenn Sie brauchen, um die Suche basierend auf den Objekt-Gleichheit über array check apache common ArrayUtils, Sie haben im Grunde überschreiben Ihre equals und hascode für name-Objekt und verwenden Sie es, aber wenn Sie möchten, verwenden Sie benutzerdefinierte Suchkriterien, ich denke, Sie implementieren müssen, um Ihren eigenen Weg und es gibt keinen eingebauten java-language-support

Den schnelleren Weg, die ich denken kann, ist die Erstellung einer Datenstruktur, die Spiegel dieser Objekte, Eigenschaft, Werte und halten Sie die internen index für jeden Wert hat.

Wenn ein Wert gesucht wird, diese internen Daten-Struktur zurück, die den index unter Verwendung der binären Suche.

Die einzige Voraussetzung ist, Ihr Objekt muss sich registrieren und aktualisieren Sie diese Struktur.

Etwas wie die folgenden imaginären UML/Python wie code:

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

Oops

Ich hoffe das ist verständlich.

Der Punkt ist, wenn Sie wirklich was zu haben, das ist wirklich schnell, Sie haben zu halten die Indizes von Eigentum

1. Ein array für die Daten
2. Ein array für jede Eigenschaft, die wiederum hätte der index, der die Daten

Zum Beispiel, wenn Sie das folgende array:

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

Hätten Sie die Positionen:

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

Und erhalten Sie zwei ( in diesem Fall ) separate Felder, welche nach der Sortierung wäre:

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

und

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

Wenn Sie suchen für ein bestimmtes Attribut, nehmen Sie das entsprechende array, zum Beispiel, wenn Sie wan zu suchen, die den Nachnamen "Reyes" Sie nehmen werde, "lastName" array

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

Und führen binarysearch-Methode auf, die es für "Reyes" die Rückkehr das element an position 2, was wiederum die Rendite des index = 1 whih ist die position "Oscar" hat auf das Originale array.

Damit sollte Dinge, die unter O(log n)

Java 8 lambda-Ausdrücke Hinzugefügt und das stream-API, also die Unterstützung ist eingebaut jetzt.

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

Es gibt viele Möglichkeiten hier. Sie können den ersten Namen entsprechend durch den Wechsel .findAny() zu .findFirst() oder führen Sie die Suche durch parallel einsetzen .parallel() nach .stream(applicants) zum Beispiel.