Il n'y a pas de support intégré, mais Apache Collections et Google Collections Les deux fournissent un support prédicat sur les collections.

Vous pouvez trouver Cette question et ses réponses utiles. Idemh avec ce développeur.com Article. P>

par exemple Utilisation de Google Collections: P>

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

Utilisez une base de données en mémoire comme Apache Derby ou HSQLDB . Profitez de JDBC, JPA ou Hibernate, qui peuvent tous faire ce que vous voulez.

Profil de votre code. Ensuite, optimisez.

La recherche d'une matrice et de "vitesse est très importante" ne va pas vraiment ensemble. À moins que votre matrice soit très faible, la recherche d'un tableau ne sera jamais rapide. C'est l'équivalent d'une numérisation de table complète dans une base de données, des performances, peu importe la façon dont vous allez sur ce sera médiocre. La clé pour trouver des choses rapidement est d'utiliser une structure indexée. Vous pouvez toujours avoir un tableau si vous en avez absolument besoin, mais la recherche doit être effectuée en utilisant une autre structure de données. Consultez une collection basée sur un hachage ou une arborescence car elles organisent des données d'une manière qui le rend très rapide à récupérer. Arbres, Treemap, HashSet, HASHMAP, etc. Données indexées de hachage sur une clé hachée, les arbres sont similaires mais stockent également leurs données dans un ordre trié.

Le moyen plus rapide que je puisse penser, est de créer une structure de données qui reflète les valeurs de la propriété des objets et maintenez l'index interne de chaque valeur.

Lorsqu'une valeur est recherchée, cette structure de données interne retournera l'index. en utilisant une recherche binaire. P>

La seule exigence est que votre objet doit enregistrer et mettre à jour cette structure. p>

Quelque chose comme l'UML / Python imaginaire suivant comme le code: p> xxx pré>

oops p>

J'espère que cela est compréhensible. P >

Le point est, si vous voulez vraiment que cela soit vraiment rapide, vous devez conserver les index par propriété p>

1. Un tableau pour les données li>
2. Un tableau pour chaque propriété, qui aurait à son tour l'index des données li> ol>

   Par exemple, si vous avez le tableau suivant: p>

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

Regardez la classe Parallelarre, il satisfait à vos besoins, mais vous devez apprendre un peu de concepts de programmation fonctionnels pour l'utiliser efficacement.

La classe ne vient pas avec JDK 6, mais pourrait venir avec JDK 7 (en discussion). En attendant, vous pouvez l'utiliser comme bibliothèque - Téléchargez le package JSR166Y à partir de: http://gee.cs.oswego.edu/dl/concurrency-Interest/ < / a>

Voir ce didacticiel pour une explication détaillée: http://www.ibm.com/DeveloperWorks/java/library/ j-jtp03048.html

Cela pourrait sembler compliqué et il est (si vous êtes simplement en train de creuser dans des algorithmes multi-filetés de haute performance). Il y a un projet groovy qui tente d'envelopper une API plus conviviale autour de la matrice parallèle, de sorte que vous voudrez peut-être aussi vous y regarder également: http://gpars.codehaus.org/ , http: // GPARS. codehaus.org/parallylizer

Streams et Lambda

Java 8 Ajout de Lambda Expressions et l'API de flux, alors le support est donc intégré maintenant. P>

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