Should I use string.isEmpty() or "".equals(string)?
JavaStringJava Problem Overview
I'm usually testing this alongside a string == null
, so I'm not really concerned about a null-safe test. Which should I use?
String s = /* whatever */;
...
if (s == null || "".equals(s))
{
// handle some edge case here
}
or
if (s == null || s.isEmpty())
{
// handle some edge case here
}
On that note - does isEmpty()
even do anything other than return this.equals("");
or return this.length() == 0;
?
Java Solutions
Solution 1 - Java
The main benefit of "".equals(s)
is you don't need the null check (equals
will check its argument and return false
if it's null), which you seem to not care about. If you're not worried about s
being null (or are otherwise checking for it), I would definitely use s.isEmpty()
; it shows exactly what you're checking, you care whether or not s
is empty, not whether it equals the empty string
Solution 2 - Java
String.equals("")
is actually a bit slower than just an isEmpty()
call. Strings store a count variable initialized in the constructor, since Strings are immutable.
isEmpty()
compares the count variable to 0, while equals will check the type, string length, and then iterate over the string for comparison if the sizes match.
So to answer your question, isEmpty()
will actually do a lot less! and that's a good thing.
Solution 3 - Java
One thing you might want to consider besides the other issues mentioned is that isEmpty()
was introduced in 1.6, so if you use it you won't be able to run the code on Java 1.5 or below.
Solution 4 - Java
You can use apache commons StringUtils isEmpty() or isNotEmpty().
Solution 5 - Java
It doesn't really matter. "".equals(str)
is more clear in my opinion.
isEmpty()
returns count == 0
;
Solution 6 - Java
I wrote a Tester
class which can test the performance:
public class Tester
{
public static void main(String[] args)
{
String text = "";
int loopCount = 10000000;
long startTime, endTime, duration1, duration2;
startTime = System.nanoTime();
for (int i = 0; i < loopCount; i++) {
text.equals("");
}
endTime = System.nanoTime();
duration1 = endTime - startTime;
System.out.println(".equals(\"\") duration " +": \t" + duration1);
startTime = System.nanoTime();
for (int i = 0; i < loopCount; i++) {
text.isEmpty();
}
endTime = System.nanoTime();
duration2 = endTime - startTime;
System.out.println(".isEmpty() duration "+": \t\t" + duration2);
System.out.println("isEmpty() to equals(\"\") ratio: " + ((float)duration2 / (float)duration1));
}
}
I found that using .isEmpty()
took around half the time of .equals("")
.