Are there any differences between different methods in each of the following groups of element retrieve operations in LinkedList
?
Returning null + removing operations: poll()
, pollFirst()
.
Returning null + not removing operations: peek()
, peekFirst()
.
Throwing exception + removing operations: pop()
, remove()
, removeFirst()
.
Throwing exception + not removing operations: element()
, getFirst()
.
Similar duplications exists in insertion methods.
If there is no such difference, I would expect it to be mentioned in the javadoc of the methods (something like the good old "This is exactly like calling ..."). Is it only a sloppy documentation, or am I missing anything?
ArrayList is faster in storing and accessing data. LinkedList is faster in manipulation of data.
Retrieval of elements in LinkedList is very slow compared to ArrayList. Because to retrieve an element, you have to traverse from beginning or end (Whichever is closer to that element) to reach that element. Retrieval operation in ArrayList is of order of O(1). Retrieval operation in LinkedList is of order of O(n).
Reason: ArrayList maintains index based system for its elements as it uses array data structure implicitly which makes it faster for searching an element in the list. On the other side LinkedList implements doubly linked list which requires the traversal through all the elements for searching an element.
LinkedList is faster than ArrayList while inserting and deleting elements, but it is slow while fetching each element.
There is no difference between them, and it is listed in the documentation too, but you have to do some recursive searching to get there.
LinkedList
implements two interfaces - Queue
and Deque
. And Deque
extends from Queue
.
Now, Deque
has defined the method - Deque#pollFirst()
and inherited the method - Queue#poll()
.
So, LinkedList
has basically these two methods defined for the two interfaces it implements.
And about the similarity between those two methods, it is listed in documentation of Deque
as:
This interface extends the Queue interface. When a deque is used as a queue, FIFO (First-In-First-Out) behavior results. Elements are added at the end of the deque and removed from the beginning. The methods inherited from the Queue interface are precisely equivalent to Deque methods as indicated in the following table:
And there is a table listing the methods of Queue
class and the equivalent Deque
method. See Deque#poll()
, Deque#peek()
for e.g. They clearly list the equivalent method.
The difference between them is version they were released with and the interfaces that LinkedList implements.
Example based on poll()
and pollFirst()
:
LinkedList
was released along with Java 1.2.
Since 1.5 LinkedList implements the Queue interface, which has
public E poll()
Since 1.6 LinkedList implements the Deque interface, which has
public E pollFirst()
edit:
It is important to keep the older implementation due to a backward compatibility.
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