Diferencia entre matches () y find () en Java Regex

Estoy tratando de entender la diferencia entre matches() y find() .

Según el Javadoc, (según tengo entendido), matches() buscará toda la cadena incluso si encuentra lo que está buscando, y find() se detendrá cuando encuentre lo que está buscando.

Si esa suposición es correcta, no puedo ver cuando quieras usar matches() lugar de find() , a menos que quieras contar el número de coincidencias que encuentre.

En mi opinión, la clase String debería tener find() lugar de matches() como un método incorporado.

Entonces para resumir:

  1. ¿Mi suposición es correcta?
  2. ¿Cuándo es útil usar matches() lugar de find() ?

matches intenta hacer coincidir la expresión con la cadena completa e implícitamente agrega un ^ al comienzo y $ al final de su patrón, lo que significa que no buscará una subcadena. De ahí el resultado de este código:

 public static void main(String[] args) throws ParseException { Pattern p = Pattern.compile("\\d\\d\\d"); Matcher m = p.matcher("a123b"); System.out.println(m.find()); System.out.println(m.matches()); p = Pattern.compile("^\\d\\d\\d$"); m = p.matcher("123"); System.out.println(m.find()); System.out.println(m.matches()); } /* output: true false true true */ 

123 es una subcadena de a123b por lo que el método find() resultado verdadero. matches() solo ‘ve’ a123b que no es lo mismo que 123 y por lo tanto da como resultado falso.

matches devuelven verdadero si toda la cadena coincide con el patrón dado. find intenta encontrar una subcadena que coincida con el patrón.

matches() solo devolverá true si la cadena completa coincide. find() intentará encontrar la siguiente ocurrencia dentro de la subcadena que coincida con la expresión regular. Tenga en cuenta el énfasis en “el próximo”. Eso significa que el resultado de llamar a find() varias veces puede no ser el mismo. Además, al usar find() puede llamar a start() para devolver la posición con la que se concordó la subcadena.

 final Matcher subMatcher = Pattern.compile("\\d+").matcher("skrf35kesruytfkwu4ty7sdfs"); System.out.println("Found: " + subMatcher.matches()); System.out.println("Found: " + subMatcher.find() + " - position " + subMatcher.start()); System.out.println("Found: " + subMatcher.find() + " - position " + subMatcher.start()); System.out.println("Found: " + subMatcher.find() + " - position " + subMatcher.start()); System.out.println("Found: " + subMatcher.find()); System.out.println("Found: " + subMatcher.find()); System.out.println("Matched: " + subMatcher.matches()); System.out.println("-----------"); final Matcher fullMatcher = Pattern.compile("^\\w+$").matcher("skrf35kesruytfkwu4ty7sdfs"); System.out.println("Found: " + fullMatcher.find() + " - position " + fullMatcher.start()); System.out.println("Found: " + fullMatcher.find()); System.out.println("Found: " + fullMatcher.find()); System.out.println("Matched: " + fullMatcher.matches()); System.out.println("Matched: " + fullMatcher.matches()); System.out.println("Matched: " + fullMatcher.matches()); System.out.println("Matched: " + fullMatcher.matches()); 

Se producirá:

 Encontrado: falso
 Encontrado: cierto - posición 4
 Encontrado: cierto - posición 17
 Encontrado: cierto - posición 20
 Encontrado: falso
 Encontrado: falso
 Emparejado: falso
 -----------
 Encontrado: verdadero - posición 0
 Encontrado: falso
 Encontrado: falso
 Emparejado: verdadero
 Emparejado: verdadero
 Emparejado: verdadero
 Emparejado: verdadero

Por lo tanto, tenga cuidado al llamar a find() varias veces si el objeto Matcher no se restableció, incluso cuando la expresión regular está rodeada con ^ y $ para coincidir con la cadena completa.

find() considerará la subcadena contra la expresión regular donde as matches() considerará la expresión completa.

find() devolverá verdadero solo si la subcadena de la expresión coincide con el patrón.

 public static void main(String[] args) { Pattern p = Pattern.compile("\\d"); String candidate = "Java123"; Matcher m = p.matcher(candidate); if (m != null){ System.out.println(m.find());//true System.out.println(m.matches());//false } } 

matches(); no almacena en búfer, sino búfers de find() . find() busca primero el final de la cadena, indiza el resultado y devuelve el valor booleano y el índice correspondiente.

Es por eso que cuando tienes un código como

 1:Pattern.compile("[az]"); 2:Pattern.matcher("0a1b1c3d4"); 3:int count = 0; 4:while(matcher.find()){ 5:count++: } 

En 4: el motor de expresiones regulares que utiliza la estructura de patrones leerá todo el código (índice a índice según lo especificado por la regex[single character] para encontrar al menos una coincidencia. Si se encuentra dicha coincidencia, se indexará y luego el bucle se ejecutará en función del resultado indexado, de lo contrario, si no hiciera el cálculo anticipado, como el que matches() ; no. La instrucción while nunca se ejecutará ya que el primer carácter de la cadena coincidente no es un alfabeto.