Comment puis-je compter le nombre de correspondances pour une expression régulière ?

Question

Disons que j'ai une chaîne qui contient ceci :

 HelloxxxHelloxxxHello

Je compile un modèle pour rechercher 'Bonjour'

 Pattern pattern = Pattern.compile("Hello");
Matcher matcher = pattern.matcher("HelloxxxHelloxxxHello");

Il devrait trouver trois matchs. Comment puis-je compter le nombre de matchs qu'il y a eu ?

J'ai essayé diverses boucles et utilisé le matcher.groupCount() mais cela n'a pas fonctionné.

Answer 1

Cela devrait fonctionner pour les correspondances qui pourraient se chevaucher :

 public static void main(String[] args) {
    String input = "aaaaaaaa";
    String regex = "aa";
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(input);
    int from = 0;
    int count = 0;
    while(matcher.find(from)) {
        count++;
        from = matcher.start() + 1;
    }
    System.out.println(count);
}

Answer 2

Depuis Java 9, vous pouvez utiliser le flux fourni par Matcher.results()

 long matches = matcher.results().count();

Answer 3

Si vous souhaitez utiliser les flux Java 8 et que vous êtes allergique aux while , vous pouvez essayer ceci :

 public static int countPattern(String references, Pattern referencePattern) {
    Matcher matcher = referencePattern.matcher(references);
    return Stream.iterate(0, i -> i + 1)
            .filter(i -> !matcher.find())
            .findFirst()
            .get();
}

Avis de non-responsabilité : cela ne fonctionne que pour les correspondances disjointes.

Exemple:

 public static void main(String[] args) throws ParseException {
    Pattern referencePattern = Pattern.compile("PASSENGER:\\d+");
    System.out.println(countPattern("[ \"PASSENGER:1\", \"PASSENGER:2\", \"AIR:1\", \"AIR:2\", \"FOP:2\" ]", referencePattern));
    System.out.println(countPattern("[ \"AIR:1\", \"AIR:2\", \"FOP:2\" ]", referencePattern));
    System.out.println(countPattern("[ \"AIR:1\", \"AIR:2\", \"FOP:2\", \"PASSENGER:1\" ]", referencePattern));
    System.out.println(countPattern("[  ]", referencePattern));
}

Cela imprime :

 2
0
1
0

Il s'agit d'une solution pour les correspondances disjointes avec les flux :

 public static int countPattern(String references, Pattern referencePattern) {
    return StreamSupport.stream(Spliterators.spliteratorUnknownSize(
            new Iterator<Integer>() {
                Matcher matcher = referencePattern.matcher(references);
                int from = 0;

                @Override
                public boolean hasNext() {
                    return matcher.find(from);
                }

                @Override
                public Integer next() {
                    from = matcher.start() + 1;
                    return 1;
                }
            },
            Spliterator.IMMUTABLE), false).reduce(0, (a, c) -> a + c);
}

Answer 4

Utilisez le code ci-dessous pour trouver le nombre de correspondances trouvées par l'expression régulière dans votre entrée

         Pattern p = Pattern.compile(regex, Pattern.MULTILINE | Pattern.DOTALL);// "regex" here indicates your predefined regex.
        Matcher m = p.matcher(pattern); // "pattern" indicates your string to match the pattern against with
        boolean b = m.matches();
        if(b)
        count++;
        while (m.find())
        count++;

Ceci est un code généralisé non spécifique cependant, adaptez-le à vos besoins

N'hésitez pas à me corriger s'il y a une erreur.