Differenza tra matches () e find () in Java Regex

Sto cercando di capire la differenza tra matches() e find() .

Secondo Javadoc, (da quello che ho capito), matches() cercherà l’intera stringa anche se trova quello che sta cercando, e find() si fermerà quando troverà quello che sta cercando.

Se questa ipotesi è corretta, non riesco a vedere ogni volta che vorrete usare matches() invece di find() , a meno che non vogliate contare il numero di corrispondenze che trova.

A mio parere, la class String dovrebbe avere find() invece di matches() come metodo integrato.

Quindi per riassumere:

  1. La mia ipotesi è corretta?
  2. Quando è utile usare matches() invece di find() ?

matches cercano di abbinare l’espressione all’intera stringa e implicitamente aggiungere un ^ all’inizio e $ alla fine del tuo modello, il che significa che non cercherà una sottostringa. Da qui l’output di questo codice:

 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 è una sottostringa di a123b quindi il metodo find() restituisce true. matches() solo ‘vede’ a123b che non è lo stesso di 123 e quindi emette false.

matches restituiscono true se l’intera stringa corrisponde al modello specificato. find cerca di trovare una sottostringa che corrisponda al modello.

matches() restituirà true solo se la stringa completa è abbinata. find() proverà a trovare l’ occorrenza successiva all’interno della sottostringa che corrisponde alla regex. Nota l’enfasi su “il prossimo”. Ciò significa che il risultato di chiamare find() più volte potrebbe non essere lo stesso. Inoltre, utilizzando find() è ansible chiamare start() per restituire la posizione in cui la sottostringa è stata abbinata.

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

Produrrà:

 Trovato: falso
 Trovato: true - posizione 4
 Trovato: true - posizione 17
 Trovato: true - posizione 20
 Trovato: falso
 Trovato: falso
 Corrispondenza: falso
 -----------
 Trovato: true - posizione 0
 Trovato: falso
 Trovato: falso
 Corrispondenza: vero
 Corrispondenza: vero
 Corrispondenza: vero
 Corrispondenza: vero

Quindi, fai attenzione quando chiami find() più volte se l’object Matcher non è stato reimpostato, anche quando l’espressione regolare è circondata da ^ e $ per corrispondere alla stringa completa.

find() prenderà in considerazione la sottostringa rispetto all’espressione regolare dove come matches() considererà l’espressione completa.

find() restituisce true solo se la sottostringa dell’espressione corrisponde al modello.

 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(); non buffer, ma find() buffer. find() cerca prima la fine della stringa, indicizza il risultato e restituisce il valore booleano e l’indice corrispondente.

Ecco perché quando hai un codice come

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

A 4: il motore regex che utilizza la struttura del pattern leggerà l’intero codice (indice da indicizzare come specificato dalla regex[single character] per trovare almeno una corrispondenza. Se tale corrispondenza viene trovata, verrà indicizzata quindi la il loop verrà eseguito in base al risultato indicizzato else se non ha eseguito il calcolo in avanti come which matches() ; no. L’istruzione while non verrebbe mai eseguita poiché il primo carattere della stringa corrispondente non è un alfabeto.