comment obtenir toute la sous-chaîne pour une regex donnée?

J'ai besoin d'obtenir toutes les sous-chaînes correspondant à une expression régulière, je sais que je peux probablement construire un automate pour elle, mais je suis à la recherche d'une solution plus simple.

le problème est, Matcher.find() ne retourne pas tous les résultats.

String str = "abaca";
Matcher matcher = Pattern.compile("a.a").matcher(str);
while (matcher.find()) {
   System.out.println(str.substring(matcher.start(),matcher.end()));
}

Le résultat est aba et pas aba,acaque je veux...

des idées?

EDIT:
un autre exemple: string=abaa, regex=a.*je suis l'espoir d'obtenir de l'aba,abaa,aa

p.s. si elle ne peut pas être réalisé en utilisant des expressions régulières, c'est aussi une réponse, je veux juste savoir que je ne suis pas ré-inventer la roue pour quelque chose de la langue déjà me donne...

source d'informationauteur amit

  1. 15

    Vous pourriez faire quelque chose comme ceci:

    import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {

    public static List<String> getAllMatches(String text, String regex) {
        List<String> matches = new ArrayList<String>();
        Matcher m = Pattern.compile("(?=(" + regex + "))").matcher(text);
        while(m.find()) {
            matches.add(m.group(1));
        }
        return matches;
    }

    public static void main(String[] args) {
        System.out.println(getAllMatches("abaca", "a.a"));
        System.out.println(getAllMatches("abaa", "a.*a"));
    }
}

    qui imprime:

    [aba, aca]
[abaa, aa]

    La seule chose, c'est que vous êtes absent aba à partir de la dernière correspond à la liste. C'est à cause de la gourmande .* dans a.*a. Vous ne pouvez pas fixer ce avec la regex. Vous pouvez faire cela en une itération sur toutes les sous-chaînes possible et appel .matches(regex) sur chaque sous-chaîne:

    public static List<String> getAllMatches(String text, String regex) {
    List<String> matches = new ArrayList<String>();
    for(int length = 1; length <= text.length(); length++) {
        for(int index = 0; index <= text.length()-length; index++) {
            String sub = text.substring(index, index + length);
            if(sub.matches(regex)) {
                matches.add(sub);
            }
        }
    }
    return matches;
}

    Si votre texte restera relativement faible, cela fonctionne, mais pour les grandes chaînes de caractères, cela peut devenir trop de calcul intense.

  2. 7

    Par défaut nouveau match commence à la fin de la précédente. Si youe les matchs peuvent se chevaucher, vous devez spécifier le point de départ manuellement:

    int start = 0;
while (matcher.find(start)) { 
    ...
    start = matcher.start() + 1;
}
  3. 0

    Utilisation matcher.find(startingFrom) dans votre while boucle, et d'augmenter startingFrom à un de plus que le début du match précédent: startingFrom = matcher.start()+1;

  4. 0

    C'est une sorte de calcul ouvertes problème. La question de toutes les correspondances possibles pour une expression régulière peut être reformulé comme 

    What are all the possible sub strings of a given String that match the given regex?

    Jusqu'à ce que votre code a vraiment besoin de faire est de (pseudo-code):

    for(String substring: allPossibleSubstrings) {
    if(PATTERN.matches(subString) {
        results.add(subString);
    }
}

    Maintenant pour une chaîne comme abaa c'est trivial: AllPossible = ["a", "ab", "aba", "abaa", "ba", "baa", "aa"]
    Vous pouvez également ajouter un peu d'intelligence en limitant la taille de la chaˆ ıne de taille minimale qui peut être adapté par l'expression régulière. Bien sûr, cela va se développer de manière exponentielle pour les grandes chaînes de