When to use the Pattern/Matcher paradigm
On the previous page, we saw that an alternative to calling String.matches()
is to use a more "explicit" approach, constructing a Pattern object and corresponding Matcher for each string to be matched. So why would you do this rather than just calling String.matches().
Before a match is performed against a regular expression, that expression must
be compiled. To compile the expression, the regex library
creates an internal object representation of that expression
that makes it efficient to perform matches. If you are performing several matches,
then it is more efficient to compile the expression once, and then create several
Matchers from the same compiled Pattern.
When you call matches() on a String, this is essentially just
a shortcut. Under the hood, the expression you pass in is compiled into a
Pattern object and then a Matcher is created from it, whose
matches() method is then called to get the result.
There are several options, such as case sensitivity, that
can be set by passing a flags parameter into Pattern.compile().
Some of these parameters can actually be set in a "raw"
expression string, but the syntax of Pattern.compile() flags is
generally more convenient.
Finding multiple instances of a pattern within a string
As well as the simple matches() method, matchers actually provide a
find() method which can be used to find multiple instances of a given
pattern within a single string. For more details, see the
section on the Matcher.find method.
An important feature of regular expressions is that the parts of the string
that match certain sub-expressions can be
captured or "pulled out" of the matcher when a match is
found. On the next page, we will look in more detail at capturing groups.