Java对正则表达式的支持

1. The java.util.regex API
Now that we've covered the theory of how to construct regular
expressions, the
hard part is over. All that's left is to investigate the Java API for applying
regexes: searching for them in strings, retrieving captured text, and replacing
matches with substitution text.
1.1 Pattern
As we've said, the regex patterns that we write as strings are,
in actuality, little programs describing how to match text. At runtime, the Java
regex package compiles these little programs into a form that it can execute
against some target text. Several simple convenience methods accept strings
directly to use as patterns. More generally, however, Java allows you to
explicitly compile your pattern and encapsulate it in an instance of a
Pattern
object. This is the most efficient way to handle patterns that
are used more than once, because it eliminates needlessly recompiling the
string. To compile a pattern, we use the static method Pattern.compile(
)
:
Pattern urlPattern = Pattern.compile("\\w+://[\\w/]*");
Once you have a Pattern
, you can ask it to create a
Matcher
object, which associates the pattern with a target string:
Matcher matcher = urlPattern.matcher( myText );
The matcher is what actually executes the matches. We'll talk
about it next. But before we do, we'll just mention one convenience method of
Pattern
. The static method Pattern.matches( )
simply takes two
stringsa regex and a target stringand determines if the target matches the
regex. This is very convenient if you want to do a quick test once in your
application. For example:
Boolean match = Pattern.matches( "\\d+\\.\\d+f?", myText );
The previous line of code can test if the string
myText
contains a Java-style floating-point number such as "42.0f."
Note that the string must match completely, to the end, to be considered a
match.
1.2 The Matcher
A Matcher
associates a patt