I need to match a sub string, and I wonder which one is faster when it comes to matching RegEx?
if ( str.matches(".*hello.*") ) {
...
}
Pattern p = Pattern.compile( ".*hello.*" );
Matcher m = p.matcher( str );
if ( m.find() ) {
...
}
And if don't need a regEx, should I use 'contains' ?
if ( str.contains("hello") ) {
...
}
Thanks.
Although matches() and using a Matcher are identical (matches() uses a Matcher in its implementation), using a Matcher can be faster if you cache and reuse the compiled Pattern. I did some rough testing and it improved performance (in my case) by 400% - the improvement depends on the regex, but there will always be sone improvement.
Although I haven't tested it, I would expect contains() to outperform any regex approach, because the algorithm is far simpler and you don't need regex for this situation.
Here are the results of 6 ways to test for a String containing a substring, with the target ("http") located at various places within a standard 60 character input:
|------------------------------------------------------------|
| Code tested with "http" in the input | µsec | µsec | µsec |
| at the following positions: | start| mid|absent|
|------------------------------------------------------------|
| input.startsWith("http") | 6 | 6 | 6 |
|------------------------------------------------------------|
| input.contains("http") | 2 | 22 | 49 |
|------------------------------------------------------------|
| Pattern p = Pattern.compile("^http.*")| | | |
| p.matcher(input).find() | 90 | 88 | 86 |
|------------------------------------------------------------|
| Pattern p = Pattern.compile("http.*") | | | |
| p.matcher(input).find() | 84 | 145 | 181 |
|------------------------------------------------------------|
| input.matches("^http.*") | 745 | 346 | 340 |
|------------------------------------------------------------|
| input.matches("http.*") | 1663 | 1229 | 1034 |
|------------------------------------------------------------|
The two-line options are where a static pattern was compiled then reused.
matches and Matcher, I was not aware of that :) Would you recommend to use contains twice to avoid this kind of match: matches("^https*.*$")? One for the 'http' and another for 'https'.They are more or less equivalent if you use m.match() in the second code snippet. String.matches() specs this :
An invocation of this method of the form
str.matches(regex)yields exactly the same result as the expressionPattern.matches(regex, str)
this in turn specifies:
An invocation of this convenience method of the form
Pattern.matches(regex, input);behaves in exactly the same way as the expression
Pattern.compile(regex).matcher(input).matches()If a pattern is to be used multiple times, compiling it once and reusing it will be more efficient than invoking this method each time.
So calling String.matches(String) in itself will not bring performance benefits, but storing a pattern (e.g. as a constant) and reusing it does.
If you use find then matches could be more efficient if the terms don't match early, as find may keep looking. But find and matches don't perform the same function, so comparison of performance is moot.
String.matches forgets the groups, underwater it simply uses Pattern.matcher(String) which does report back the groups, no matter if you call matches() or find() on the resulting Matcher.find, you would almost get the same result for ".*hello.*" as for "hello", main difference being that the first one matches the last hello in the string (".*" reaches to the end, then with traceback "hello.*" is found), just "hello" matches the first hello.
matchin one andfindin another?findwith a regexp that starts and ends with.*- you don't need the.*withfind. And yes, if what you're seeking is just aString, you should absolutely usecontains.