Différence entre Java Matcher find () et matches ()

1. Vue d'ensemble

Lorsque vous travaillez avec des expressions régulières en Java, nous souhaitons généralement rechercher une séquence de caractères pour un motif donné . Pour faciliter cela, l'API Java Regular Expressions fournit la classe Matcher , que nous pouvons utiliser pour faire correspondre une expression régulière donnée à un texte.

En règle générale, nous voudrons presque toujours utiliser l'une des deux méthodes populaires de la classe Matcher :

  • trouver()
  • allumettes()

Dans ce rapide didacticiel, nous découvrirons les différences entre ces méthodes à l'aide d'un simple ensemble d'exemples.

2. La méthode find ()

En termes simples, la méthode find () essaie de trouver l'occurrence d'un modèle regex dans une chaîne donnée . Si plusieurs occurrences sont trouvées dans la chaîne, le premier appel à find () passera à la première occurrence. Par la suite, chaque appel suivant à la méthode find () ira à la prochaine occurrence correspondante, une par une.

Imaginons que nous voulions rechercher la chaîne fournie «au revoir 2019 et bienvenue 2020» pour les nombres à quatre chiffres uniquement.

Pour cela, nous utiliserons le modèle «\\ d \\ d \\ d \\ d» :

@Test public void whenFindFourDigitWorks_thenCorrect() { Pattern stringPattern = Pattern.compile("\\d\\d\\d\\d"); Matcher m = stringPattern.matcher("goodbye 2019 and welcome 2020"); assertTrue(m.find()); assertEquals(8, m.start()); assertEquals("2019", m.group()); assertEquals(12, m.end()); assertTrue(m.find()); assertEquals(25, m.start()); assertEquals("2020", m.group()); assertEquals(29, m.end()); assertFalse(m.find()); }

Comme nous avons deux occurrences dans cet exemple - 2019 et 2020 - la méthode find () retournera true deux fois, et une fois qu'elle atteindra la fin de la région de correspondance, elle retournera false .

Une fois que nous avons trouvé une correspondance, nous pouvons utiliser des méthodes telles que start () , group () et end () pour obtenir plus de détails sur la correspondance , comme indiqué ci-dessus.

La méthode start () donnera l'index de début de la correspondance, end () retournera le dernier index du caractère après la fin de la correspondance et group () retournera la valeur réelle de la correspondance .

3. La méthode find (int)

Nous avons également la version surchargée de la méthode find - find (int) . Il prend l'index de départ comme paramètre et considère l'index de départ comme le point de départ pour rechercher des occurrences dans la chaîne .

Voyons comment utiliser cette méthode dans le même exemple que précédemment:

@Test public void givenStartIndex_whenFindFourDigitWorks_thenCorrect() { Pattern stringPattern = Pattern.compile("\\d\\d\\d\\d"); Matcher m = stringPattern.matcher("goodbye 2019 and welcome 2020"); assertTrue(m.find(20)); assertEquals(25, m.start()); assertEquals("2020", m.group()); assertEquals(29, m.end()); }

Comme nous avons fourni un index de départ de 20 , nous pouvons voir qu'il n'y a maintenant qu'une seule occurrence trouvée - 2020, qui se produit comme prévu après cet index . Et, comme c'est le cas avec find () , nous pouvons utiliser des méthodes comme start () , group () et end () pour extraire plus de détails sur la correspondance.

4. La méthode matches ()

D'autre part, la méthode matches () essaie de faire correspondre la chaîne entière avec le modèle .

Pour le même exemple, matches () renverra false :

@Test public void whenMatchFourDigitWorks_thenFail() { Pattern stringPattern = Pattern.compile("\\d\\d\\d\\d"); Matcher m = stringPattern.matcher("goodbye 2019 and welcome 2020"); assertFalse(m.matches()); } 

En effet, il essaiera de faire correspondre «\\ d \\ d \\ d \\ d» à la chaîne entière « au revoir 2019 et bienvenue 2020» - contrairement aux méthodes find () et find (int) , qui recherchez l'occurrence du motif n'importe où dans la chaîne .

Si nous remplaçons la chaîne par le nombre à quatre chiffres «2019» , matches () renverra true :

@Test public void whenMatchFourDigitWorks_thenCorrect() { Pattern stringPattern = Pattern.compile("\\d\\d\\d\\d"); Matcher m = stringPattern.matcher("2019"); assertTrue(m.matches()); assertEquals(0, m.start()); assertEquals("2019", m.group()); assertEquals(4, m.end()); assertTrue(m.matches()); }

Comme indiqué ci-dessus, nous pouvons également utiliser des méthodes telles que start () , group () et end () pour recueillir plus de détails sur la correspondance. Un point intéressant à noter est que l'appel de find () plusieurs fois peut retourner une sortie différente après l'appel de ces méthodes, comme nous l'avons vu dans notre premier exemple, mais matches () retournera toujours la même valeur.

5. Conclusion

Dans cet article, nous avons vu comment find () , find (int) et matches () diffèrent les uns des autres avec un exemple pratique. Nous avons également vu comment diverses méthodes telles que start () , group () et end () peuvent nous aider à extraire plus de détails sur une correspondance donnée .

Comme toujours, le code source complet de l'article est disponible à l'adresse over sur GitHub.