The documentation for ArrayDeque
says:
This class is likely to be faster than Stack when used as a stack, and faster than LinkedList when used as a queue.
There is no mention of the difference between using an ArrayDeque
as a stack and using an ArrayList
. You can use an ArrayList
as a stack as follows.
list.add(object); // push object = list.remove(list.size() - 1); // pop
I found that when I used an ArrayList
in this way only, its performance is worse than ArrayDeque
. What accounts for this difference? Surely, it can't just be the calls to size()
? Internally, both ArrayList
and ArrayDeque
are implemented using an Object[]
that is replaced by a larger array when required, so surely the performance should be about the same?
There are multiple reasons to use ArrayDeque instead of Stack as ArrayDeque is a Doubly ended Queue implemented as an Array. So, it can grow relatively faster. If you do not plan to use syncronized stack, then ArrayDeque is probably better than Stack which is Thread safe(and hence slow).
ArrayDeque class is likely to be faster than Stack when used as a stack. ArrayDeque class is likely to be faster than LinkedList when used as a queue.
When to use ArrayList and when to use ArrayDeque? ArrayDeque has the ability to add or remove the elements from both ends (head or tail), on the other hand removing last element from ArrayList takes O(n) time as it traverses the whole list to reach the end.
For beginners, using ArrayListA stack is one of the most simplest data structure to understand. If you had data structures in your academia, you already know what it means. It's a simple Last In First Out (LIFO) queue. What that means is the last element to enter the stack will be first element to go out of the stack.
The main difference between both implementation is the resize strategy
ArrayList
is resized to a new size of oldCapacity + (oldCapacity >> 1)
, resulting in an increse of ~50%. The default capacity is 10, resulting in a capacities after resize of 15, 22, 33, 49, 73, 109, 163, 244, 366...
ArrayDeque
is always resized to a power of 2. On resize, the capacity is doubled. Starting with the default of 16, the resuling capacities after resize are 32, 64, 128, 256,...
So the ArrayDeque reaches higher capacities with much less resize operation, which are costly because of array copy. I.e. to store 256 in default-sized ArrayList, it requires 9 resize calls, while the ArrayDeque only need 4. Array copy may be fast, but may also require a GC to free some space for the new data sets, in addition to the memory copy costs (where the ArrayDeque might also perform better due to it's alignment to power-of-2).
Both datastructures have best-case complexity of O(1) for push and pop through direct access on either head
& tail
(ArrayDequeue) respectively add and remove(Last) size
(ArrayList)
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With