In any case, the performance difference between the two will be negligible, especially once you do the comparison you need to do to see if the list is empty ( l.size() = 0). You could try calling l.size() a couple of million times and l.isEmpty() a couple of million times in two separate programs but in theory the compiler could just optimize away all those calls since you're not actually doing anything with the results. Most likely calling l.size() has loaded the size of your list into your cpu cache and calling l.isEmpty() is a lot faster as a result. You can't test the speed of calling l.size() and l.isEmpty() at the same time, since they both query the same value. Here eTime-sTime>eeTime-eTime in all cases Why?įirst off, it's probably because of your testing code. A naïve linked list operation might not do this, and in the more general sense there is no efficiency guarantee on implementations of List. * I originally wrote LinkedList here, implicitly referencing, though that particular implementation does store its size explicitly, making size() an O(1) operation here. isEmpty() is a clearer definition of what it is you actually care about and are testing, and so makes your code a bit more easily understandable.Even in the best case, size() = 0 is still not faster than isEmpty(), so there is no compelling reason to ever use the former.If things change a few years down the line with code restructuring, testing will show that 'it works,' but things are running less efficiently than before.This is bad programming practice to tie yourself down to a specific implementation.So if you absolutely know that the list is an implementation of ArrayList and will never ever change, then it does not really matter but:

Here is my TestCode import įor ArrayList, yes - you are correct that the operations take (roughly) the same time.įor other implementations of List - for example, a naïve linked list* - counting the size might take a very long time, while you only actually care whether it is greater than zero. If we just write a simple program to get the time take by both the methods, that case size() will take more isEmpty() in all cases, why this so? * Returns true if this list contains no elements. * Returns the number of elements in this list. When I look at the implementation in ArrayList, then it looks like the speed should be the same: Why is list.size()>0 slower than list.isEmpty() in Java? On other words why isEmpty() is preferable over size()>0?

Java collections isempty