I am trying to to understand why Java’s ArrayDeque is better than Java’s LinkedList as they both implement Deque interface.
I hardly see someone using ArrayDeque in their code. If someone sheds more light into how ArrayDeque is implemented, it would be helpful.
If I understand it, I will be more confident using it. I could not clearly understand the JDK implementation as to the way it manages head and tail references.
Linked structures are possibly the worst structure to iterate with a cache miss on each element. On top of it they consume way more memory.
If you need add/remove of the both ends, ArrayDeque is significantly better than a linked list. Random access each element is also O(1) for a cyclic queue.
The only better operation of a linked list is removing the current element during iteration.
ArrayDeque is new with Java 6, which is why a lot of code (especially projects that try to be compatible with earlier Java versions) don’t use it.
It’s “better” in some cases because you’re not allocating a node for each item to insert; instead all elements are stored in a giant array, which is resized if it gets full.
I believe that the main performance bottleneck in
LinkedList is the fact that whenever you push to any end of the deque, behind the scene the implementation allocates a new linked list node, which essentially involves JVM/OS, and that’s expensive. Also, whenever you pop from any end, the internal nodes of
LinkedList become eligible for garbage collection and that’s more work behind the scene.
If it might be of interest, I have a proof that adding an element to
ArrayDeque runs in amoritzed constant time; refer to this.
Accessing an element in ArrayDeque is always faster compared to LinkedList with O(1) for accessing elements. In Linked list, it will take O(N) to find last element.
ArrayDeque is memory efficient since you don’t have to keep track of next node unlike in Linked List.
Even as per java documentation, it has been quoted that
ArrayDeque is Resizable-array implementation of the Deque interface. Array deques have no capacity restrictions; they grow as necessary to support usage. They are not thread-safe; in the absence of external synchronization, they do not support concurrent access by multiple threads. Null elements are prohibited. This class is likely to be faster than Stack when used as a stack, and faster than LinkedList when used as a queue.
Benchmarking of these two proves that ArrayDeque is faster.
All the people criticizing a
LinkedList, think about every other guy that has been using
List in Java probably uses
ArrayList and an
LinkedList most of the times because they have been before Java 6 and because those are the ones being taught as a start in most books.
But, that doesn’t mean, I would blindly take
ArrayDeque‘s side. If you want to know, take a look at the below benchmark done by Brian.
The test setup considers:
- Each test object is a 500 character String. Each String is a different object in memory.
- The size of the test array will be varied during the tests.
- For each array size/Queue-implementation combination, 100 tests are run and average time-per-test is calculated.
- Each tests consists of filling each queue with all objects, then removing them all.
- Measure time in terms of milliseconds.
- Below 10,000 elements, both LinkedList and ArrayDeque tests averaged at a sub 1 ms level.
- As the sets of data get larger, the differences between the ArrayDeque and LinkedList average test time gets larger.
- At the test size of 9,900,000 elements, the LinkedList approach took ~165% longer than the ArrayDeque approach.
- If your requirement is storing 100 or 200 elements, it wouldn’t make
much of a difference using either of the Queues.
- However, if you are developing on mobile, you may want to use an
ArrayDequewith a good guess of maximum capacity
that the list may be required to be because of strict memory constraint.
- A lot of code exists, written using a
LinkedListso tread carefully when deciding to use a
ArrayDequeespecially because it DOESN’T implement the
Listinterface(I think that’s reason big enough). It may be that your codebase talks to the List interface extensively, most probably and you decide to jump in with an
ArrayDeque. Using it for internal implementations might be a good idea…
LinkedList<E> have both implemented
Deque<E> Interface, but the ArrayDeque uses basically Object array
E for keeping the elements inside its Object, so it generally uses index for locating the head and tail elements.
In a word, it just works like Deque (with all Deque’s method), however uses array’s data structure. As regards which one is better, depends on how and where you use them.
Time complexity for ArrayDeque for accessing a element is O(1) and that for LinkList is is O(N) to access last element. ArrayDeque is not thread safe so manually synchronization is necessary so that you can access it through multiple threads and so they they are faster.