Recherche d'une expression régulière dans une java arraylist

ArrayList <String> list = new ArrayList(); 
list.add("behold");
list.add("bend");
list.add("bet");
list.add("bear");
list.add("beat");
list.add("become");
list.add("begin");

Il y a une façon pour la recherche de regexp bea.* et d'obtenir les indices comme dans ArrayList.indexOf ?

EDIT: le retour des articles est bien, mais j'ai besoin de quelque chose avec plus de performances qu'un Linéaire de recherche

  • Vous pouvez pas de meilleures performances si vous mettez vos chaînes dans une Liste. Est votre regex toujours un préfixe, ou voulez-vous gérer tout regex?
  • Alors lequel la structure de données dois-je utiliser? Ma regex est toujours un préfixe.
  • Je recommande certains automates structure de données. en.wikipedia.org/wiki/Trie
  • Il est fondamental que, sauf si vous savez quelque chose à propos de la commande de la liste, alors vous ne peut pas faire mieux que la recherche linéaire. C'est parce que, sans rien connaître de la commande, afin de repérer chaque élément correspondant vous devez tester chaque élément. Si vous voulez seulement le premier élément correspondant, alors la seule optimisation que vous pouvez appliquer est de tester dans un ordre qui permet de mettre fin à la première frappe( c'est à dire la première à la dernière). Si vous souhaitez sous-linéaire de la performance que vous avez à nous dire comment vos éléments sont ordonnés
InformationsquelleAutor kmilo | 2008-11-20
  1. 16

    Herms a obtenu de bonnes bases. Si vous voulez les Chaînes et non les indices, alors vous pouvez l'améliorer en utilisant le Java 5 boucle foreach:

    import java.util.regex.Pattern;
import java.util.ListIterator;
import java.util.ArrayList;

/**
 * Finds the index of all entries in the list that matches the regex
 * @param list The list of strings to check
 * @param regex The regular expression to use
 * @return list containing the indexes of all matching entries
 */
List<String> getMatchingStrings(List<String> list, String regex) {

  ArrayList<String> matches = new ArrayList<String>();

  Pattern p = Pattern.compile(regex);

  for (String s:list) {
    if (p.matcher(s).matches()) {
      matches.add(s);
    }
  }

  return matches
}
    • J'ai pensé du retour de la réelle correspondance de chaînes, mais la question a demandé en particulier que la indicies. Retour de la correspondance de chaînes de caractères est généralement un peu plus propre si.
    InformationsquelleAutor DJClayworth
  2. 8

    Est-il intégré dans la méthode? Pas que je sache. Cependant, il devrait être assez facile à faire vous-même. Voici quelques complètement le code non testé qui devrait vous donner l'idée de base:

    import java.util.regex.Pattern;
import java.util.ListIterator;
import java.util.ArrayList;

/**
 * Finds the index of all entries in the list that matches the regex
 * @param list The list of strings to check
 * @param regex The regular expression to use
 * @return list containing the indexes of all matching entries
 */
List<Integer> getMatchingIndexes(List<String> list, String regex) {
  ListIterator<String> li = list.listIterator();

  List<Integer> indexes = new ArrayList<Integer>();

  while(li.hasNext()) {
    int i = li.nextIndex();
    String next = li.next();
    if(Pattern.matches(regex, next)) {
      indexes.add(i);
    }
  }

  return indexes;
}

    Je pourrait avoir l'utilisation de Modèle et ListIterator pièces un peu de mal (je n'ai jamais utilisé non plus), mais cela devrait vous donner l'idée de base. Vous pouvez également faire une simple boucle for à la place de la boucle while sur l'itérateur.

    • Personnellement, je pense que les méthodes de l'api doit prendre des arguments et valeurs de retour de la plus abstraite possible. Donc, mon pédant correction de votre réponse serait: public List<int> getMatchingIndices(List<String>liste, String regex){..}
    • Bon point. Je viens de lancer très rapide et ne pas payer autant d'attention à ce genre de choses.
    • Pour info, <int> n'est pas valide d'un paramètre de type. Vous devez faire une Liste<Integer>. Aussi, lorsque vous utilisez une expression régulière dans une boucle comme ceci, de les compiler dans un Modèle objet avant d'entrer dans la boucle, comme DJClayworth fait.
    • Hmm, je pensais que l'autoboxing pris soin de l'int->Entier chose. Oh bien. Comme je l'ai dit, il a pas été testés et rapidement jetés ensemble 🙂
    • l'autoboxing vous permettra de .add un int et la convertir en un Integer mais un type primitif ne peut pas être utilisé dans un paramètre de type comme ça.
    InformationsquelleAutor Herms
  3. 4

    Une option est d'utiliser Apache Commons CollectionUtils "select" de la méthode. Vous devez créer un Prédicat de l'objet (un objet avec un seul "évaluer", méthode qui utilise l'expression régulière pour vérifier pour un match et renvoie true ou false), et puis vous pouvez rechercher des éléments dans la liste qui correspondent. Cependant, il ne renvoie pas à l'index, elle retourne une collection contenant les éléments eux-mêmes.

    InformationsquelleAutor Jacob Mattison
  4. 3

    C'est un liner dans la goyave:

    final Iterable<String> matches = Iterables.filter(myStrings, Predicates.contains(Pattern.compile("myPattern")));

for (final String matched : matches) {
   ...
}
    InformationsquelleAutor grinch
  5. 1

    Je ne crois pas qu'il y est une API Java façon de faire cela, ni est-il un Apache Commons moyen de le faire. Il ne serait pas difficile de rouler votre propre cependant.

    InformationsquelleAutor SCdF
  6. 0

    Ce sera un thread réveil, mais pourrait être utile à quelqu'un. Vous ne pourriez pas besoin d'indices, probablement la prochaine étape sera de faire quelque chose sur les éléments correspondant à l'expression régulière et, par conséquent, vous avez demandé pour les index. Mais vous pouvez utiliser Java8 ruisseaux et expression lambda:

      import java.util.regex.Pattern;
  import java.util.stream.Collectors;
  import java.util.List;

  ...

  var pattern = Pattern.compile(define);  //var is Java 10 feature

  List<String> list = originalList
      .stream()
      .filter(e -> pattern.matcher(e).matches())
      .collect(Collectors.toList());

    Vous pouvez prendre la liste d'origine, de les convertir en un flux de données, exécuter un filtre sur ce qui fonctionne lambda pour correspondre à votre modèle et de la convertir à une Liste. Mais vous pouvez garder les rivières et les exécuter .foreach sur elle avec une autre expression lambda.

    InformationsquelleAutor muni764