Checking if a collection is empty in Java: which is the best method?
JavaCollectionsIs EmptyJava Problem Overview
I have two ways of checking if a List is empty or not
if (CollectionUtils.isNotEmpty(listName))
and
if (listName != null && listName.size() != 0)
My arch tells me that the former is better than latter. But I think the latter is better.
Can anyone please clarify it?
Java Solutions
Solution 1 - Java
You should absolutely use isEmpty()
. Computing the size()
of an arbitrary list could be expensive. Even validating whether it has any elements can be expensive, of course, but there's no optimization for size()
which can't also make isEmpty()
faster, whereas the reverse is not the case.
For example, suppose you had a linked list structure which didn't cache the size (whereas LinkedList<E>
does). Then size()
would become an O(N) operation, whereas isEmpty()
would still be O(1)
.
Additionally of course, using isEmpty()
states what you're actually interested in more clearly.
Solution 2 - Java
CollectionUtils.isNotEmpty
checks if your collection is not null and not empty. This is better comparing to double check but only if you have this Apache library in your project. If you don't then use:
if(list != null && !list.isEmpty())
Solution 3 - Java
Unless you are already using CollectionUtils I would go for List.isEmpty()
, less dependencies.
Performance wise CollectionUtils will be a tad slower. Because it basically follows the same logic but has additional overhead.
So it would be readability vs. performance vs. dependencies. Not much of a big difference though.
Solution 4 - Java
if (CollectionUtils.isNotEmpty(listName))
Is the same as:
if(listName != null && !listName.isEmpty())
In first approach listName
can be null and null pointer exception will not be thrown. In second approach you have to check for null manually. First approach is better because it requires less work from you. Using .size() != 0
is something unnecessary at all, also i learned that it is slower than using .isEmpty()
Solution 5 - Java
If you have the Apache common utilities in your project rather use the first one. Because its shorter and does exactly the same as the latter one. There won't be any difference between both methods but how it looks inside the source code.
Also a empty check using
listName.size() != 0
Is discouraged because all collection implementations have the
listName.isEmpty()
function that does exactly the same.
So all in all, if you have the Apache common utils in your classpath anyway, use
if (CollectionUtils.isNotEmpty(listName))
in any other case use
if(listName != null && listName.isEmpty())
You will not notice any performance difference. Both lines do exactly the same.
Solution 6 - Java
Apache Commons' CollectionUtils.isNotEmpty(Collection) is a NULL-SAFE check
Returns TRUE is the Collection/List is not-empty and not-null Returns FALSE if the Collection is Null
Example:
List<String> properties = new ArrayList();
...
if (CollectionUtils.isNotEmpty(properties)) {
// process the list
} else {
// list is null or empty
}
Solution 7 - Java
isEmpty()
Returns true if this list contains no elements.
http://docs.oracle.com/javase/1.4.2/docs/api/java/util/List.html
Solution 8 - Java
A good example of where this matters in practice is the ConcurrentSkipListSet
implementation in the JDK, which states:
> Beware that, unlike in most collections, the size method is not a constant-time operation.
This is a clear case where isEmpty()
is much more efficient than checking whether size()==0
.
You can see why, intuitively, this might be the case in some collections. If it's the sort of structure where you have to traverse the whole thing to count the elements, then if all you want to know is whether it's empty, you can stop as soon as you've found the first one.
Solution 9 - Java
Use CollectionUtils.isEmpty(Collection coll)
Null-safe check if the specified collection is empty. Null returns true.
Parameters: coll - the collection to check, may be null
Returns: true if empty or null
Solution 10 - Java
The org.apache.commons.collections4.CollectionUtils isEmpty() method is used to check any collections(List, Set, etc.) are empty or not. It checks for null as well as size of collections. The CollectionUtils isEmpty() is a static method, which accepts Collection as a parameter.
Solution 11 - Java
I would use the first one. It is clear to see right away what it does. I dont think the null check is necessary here.
Solution 12 - Java
To Check collection is empty, you can use method: .count(). Example:
DBCollection collection = mMongoOperation.getCollection("sequence");
if(collection.count() == 0) {
SequenceId sequenceId = new SequenceId("id", 0);
mMongoOperation.save(sequenceId);
}