Différence entre matches () et find () dans Java Regex

J’essaie de comprendre la différence entre des matches() et des find() .

Selon Javadoc, (d’après ce que je comprends), matches() recherchera la chaîne entière même s’il trouve ce qu’il cherche, et find() s’arrêtera lorsqu’il trouvera ce qu’il cherche.

Si cette hypothèse est correcte, je ne peux pas voir à quel moment vous souhaitez utiliser matches() au lieu de find() , sauf si vous souhaitez compter le nombre de correspondances trouvées.

A mon avis, la classe Ssortingng devrait alors avoir find() au lieu de matches() comme méthode intégrée.

Donc pour résumer:

  1. Est-ce que mon hypothèse est correcte?
  2. Quand est-il utile d’utiliser des matches() au lieu de find() ?

matches tente de faire correspondre l’expression à la chaîne entière et d’append implicitement un ^ au début et $ à la fin de votre modèle, ce qui signifie qu’il ne recherchera pas de sous-chaîne. D’où la sortie de ce code:

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

123 est une sous-chaîne de a123b donc la méthode find() a123b true. matches() uniquement ‘voit’ a123b qui n’est pas la même chose que 123 et a123b donc un résultat faux.

matches renvoient true si la chaîne entière correspond au modèle donné. find essaie de trouver une sous-chaîne qui correspond au modèle.

matches() ne retournera true que si la chaîne complète correspond. find() essaiera de trouver l’ occurrence suivante dans la sous-chaîne correspondant à l’expression régulière. Notez l’accent mis sur “le prochain”. Cela signifie que le résultat de l’appel de find() plusieurs fois peut ne pas être le même. De plus, en utilisant find() vous pouvez appeler start() pour renvoyer la position de la sous-chaîne.

 final Matcher subMatcher = Pattern.comstack("\\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.comstack("^\\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()); 

Va sortir:

 Trouvé: faux
 Trouvé: vrai - position 4
 Trouvé: vrai - position 17
 Trouvé: vrai - position 20
 Trouvé: faux
 Trouvé: faux
 Matched: false
 -----------
 Trouvé: vrai - position 0
 Trouvé: faux
 Trouvé: faux
 Matched: true
 Matched: true
 Matched: true
 Matched: true

Donc, soyez prudent lorsque vous appelez plusieurs fois find() si l’object Matcher n’a pas été réinitialisé, même si l’expression régulière est entourée de ^ et de $ pour correspondre à la chaîne complète.

find() considérera la sous-chaîne avec l’expression régulière où matches() prendra en compte l’expression complète.

find() renvoie true uniquement si la sous-chaîne de l’expression correspond au modèle.

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

matches(); ne tampon pas, mais find() tampons. find() recherche d’abord la fin de la chaîne, indexe le résultat et renvoie la valeur booléenne et l’index correspondant.

C’est pourquoi lorsque vous avez un code comme

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

At 4: le moteur regex utilisant la structure pattern lira l’intégralité de votre code (index à indexer comme spécifié par le regex[single character] pour trouver au moins une correspondance. Si une telle correspondance est trouvée, elle sera indexée puis la loop s’exécutera sur la base du résultat indexé sinon s’il n’a pas fait de calcul anticipé comme celui qui matches() , mais pas à l’instruction while le premier caractère de la chaîne correspondante n’est pas un alphabet.