Recuento de coincidencias de java regex

Digamos que tengo un archivo y el archivo contiene esto:

HelloxxxHelloxxxHello 

Recopilo un patrón para buscar ‘Hola’

 Pattern pattern = Pattern.compile("Hello"); 

Luego utilizo un inputstream para leer en el archivo y convertirlo en una cadena para que pueda ser regex.

Una vez que el emparejador encuentra una coincidencia en el archivo, lo indica, pero no me dice cuántas coincidencias encontró; simplemente que encontró una coincidencia dentro de la Cadena.

Entonces, como la cadena es relativamente corta, y el buffer que estoy usando tiene 200 bytes, debería encontrar tres coincidencias. Sin embargo, simplemente dice coincidencia, y no me da un recuento de cuántas coincidencias hubo.

¿Cuál es la manera más fácil de contar la cantidad de coincidencias que se produjeron dentro de la Cadena? He intentado varios bucles for y uso el matcher.groupCount () pero no llego rápido a ninguna parte.

matcher.find() no encuentra todas las coincidencias, solo la siguiente coincidencia.

Tendrás que hacer lo siguiente:

 int count = 0; while (matcher.find()) count++; 

Por matcher.groupCount() , matcher.groupCount() es algo completamente diferente.

Ejemplo completo :

 import java.util.regex.*; class Test { public static void main(String[] args) { String hello = "HelloxxxHelloxxxHello"; Pattern pattern = Pattern.compile("Hello"); Matcher matcher = pattern.matcher(hello); int count = 0; while (matcher.find()) count++; System.out.println(count); // prints 3 } } 

Manejo de coincidencias superpuestas

Al contar las coincidencias de aa en aaaa el fragmento anterior te dará 2 .

 aaaa aa aa 

Para obtener 3 coincidencias, es decir, este comportamiento:

 aaaa aa aa aa 

Tienes que buscar una coincidencia en el índice + 1 siguiente manera:

 String hello = "aaaa"; Pattern pattern = Pattern.compile("aa"); Matcher matcher = pattern.matcher(hello); int count = 0; int i = 0; while (matcher.find(i)) { count++; i = matcher.start() + 1; } System.out.println(count); // prints 3 

Esto debería funcionar para las coincidencias no disjuntos:

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

Esto puede ayudar:

 public static void main(String[] args) { String hello = "HelloxxxHelloxxxHello"; String []matches = hello.split("Hello"); System.out.println(matches.length); // prints 3 } 

Si desea usar las secuencias de Java 8 y es alérgico a los ciclos while, puede intentar esto:

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

Descargo de responsabilidad: esto solo funciona para partidas disjuntas.

Ejemplo:

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

Esto se imprime:

 2 0 1 0