Re: a boolean method inside an inner class.....
Roedy Green wrote:
there are several ways to deal with the case problem:
Here's a summary of memory/speed/complexity tradeoffs among the approaches.
(1)
return name.toLowerCase().endsWith(".jpg")
is the easiest to code. It also handles *.Jpg.
Creates a temporary String, makes /n/ + 1 passes where /n/ is the number of
different file suffixes to check, ignoring case. Only the "toLowerCase()"
pass encompasses the entire String, the rest just examine enough of the ending
to determine a match.
(2)
return name.endsWith(".jpg") || name.endsWith( ".JPG");
won't catch *.Jpg but this code should be faster.
Creates no additional Strings. Makes /n/ passes where /n/ is the number of
endings for which you're searching. Those are "from-the-end, only to match"
passes, not the entire length of the String.
This might be faster than the first choice for only one suffix, but if you are
checking multiple suffixes the first approach gets complete case independence
with half as many comparisons as the second, amortizing the cost of the
toLowerCase() call.
(3)
if ( name.length() < ".jpg".length() ) return false;
final String ext = name.substring( name.length() - ".jpg".length());
return ext.equalsIgnoreCase( ".jpg" );
In most JVMs will not create a new temporary character sequence, just a new
reference to an offset in the original String's character sequence. Makes /n/
passes through just the ending part of the String, with /k/ calculations of
ending String (where /k/ is the number of different ending lengths).
a bit verbose, but would be quick if encapsulated in a method.
with some additional risk of bugs due to the more complex code.
Masochists can covert it to a one-line expression.
If there's only one ending to check. If you generalize to multiple file
suffixes it probably can't be a one-liner.
Without profiling one cannot tell which of these three would be the fastest.
It depends on how many different file suffixes are of interest, whether mixed
case is an issue, how different JVMs optimize things and other variables. The
speed difference among the three is likely to be not significant. I
personally would use the first one, the toLowerCase() variant, unless I had
proof that it was a bottleneck.
--
Lew