pattern.matcher () vs pattern.matches ()

Me pregunto por qué los resultados del patrón java regex pattern.matcher () y pattern.matches () difieren cuando se proporciona la misma expresión regular y la misma cadena

String str = "hello+"; Pattern pattern = Pattern.compile("\\+"); Matcher matcher = pattern.matcher(str); while (matcher.find()) { System.out.println("I found the text " + matcher.group() + " starting at " + "index " + matcher.start() + " and ending at index " + matcher.end()); } System.out.println(java.util.regex.Pattern.matches("\\+", str)); 

El resultado de lo anterior es:

 I found the text + starting at index 5 and ending at index 6 false 

Descubrí que usar una expresión para que coincida con la cadena completa funciona bien en caso de matches(".*\\+") .

pattern.matcher(String s) devuelve un Matcher que puede encontrar patrones en String s . Pruebas pattern.matches(String str) , si toda la String ( str ) coincide con el patrón.

En resumen (solo para recordar la diferencia):

  • pattern.matcher – prueba si la cadena contiene un patrón
  • pattern.matches – prueba si la cadena es-un patrón

Matcher.find() intenta encontrar la siguiente subsecuencia de la secuencia de entrada que coincide con el patrón.

Pattern.matches(String regex, CharSequence input) comstack la expresión regular en un Matcher y devuelve Matcher.matches() .

Matcher.matches intenta hacer coincidir toda la región (cadena) con el patrón (Regex).

Entonces, en tu caso, Pattern.matches("\\+", str) devuelve un falso ya que str.equals("+") es falso.

Desde el Javadoc, consulte si, y solo si, toda la sección de la región

  /** * Attempts to match the entire region against the pattern. * * 

If the match succeeds then more information can be obtained via the * start, end, and group methods.

* * @return true if, and only if, the entire region sequence * matches this matcher's pattern */ public boolean matches() { return match(from, ENDANCHOR); }

Entonces, si tu String fuera simplemente “+”, obtendrías un resultado verdadero.

matches intenta hacer coincidir la expresión con toda la cadena. Es decir, comprueba si toda la cadena es un patern o no. conceptualmente creo que es así, implícitamente agrega un ^ al comienzo y $ al final de tu patrón.

Para, String str = “hello +”, si quiere que matches () devuelva verdadero, necesita tener un patrón como “. \ +.

Espero que esto haya respondido tu pregunta.

Pattern.matches está probando todo el String, en su caso debería usar:

  System.out.println(java.util.regex.Pattern.matches(".*\\+", str)); 

Significado de cualquier cadena y un símbolo +

Creo que su pregunta debería ser realmente “¿Cuándo debería usar el método Pattern.matches() ?”, Y la respuesta es “Nunca”. ¿Estabas esperando que devolviera una matriz de las subcadenas coincidentes, como lo hacen los métodos de Matches de .NET? Esa es una expectativa perfectamente razonable, pero no, Java no tiene nada de eso.

Si solo quieres hacer una coincidencia rápida y sucia, adorna la expresión regular con .* En cualquier extremo y usa el método de matches() la cadena matches() :

 System.out.println(str.matches(".*\\+.*")); 

Si desea extraer varias coincidencias o acceder a información sobre una coincidencia posteriormente, cree una instancia de Matcher y utilice sus métodos, como lo hizo en su pregunta. Pattern.matches() no es más que una oportunidad desperdiciada.

 Matcher matcher = pattern.matcher(text); 

En este caso, se devolverá una instancia de objeto de emparejamiento que realice operaciones de coincidencia en el texto de entrada interpretando el patrón. Entonces podemos usar, matcher.find() para que coincida con no. de patrones del texto de entrada.

 (java.util.regex.Pattern.matches("\\+", str)) 

Aquí, el objeto de coincidencia se creará implícitamente y se devolverá un booleano que coincida con el texto completo con el patrón. Esto funcionará igual que la función str.matches(regex) en String.

El código equivalente a java.util.regex.Pattern.matches("\\+", str) sería:

 Pattern.compile("\\+").matcher(str).matches(); 

método find encontrará la primera aparición del patrón en la cadena.