LinkedList vs Arraylist- an in depth look at java.util.LinkedList

 2015, Marcus Biel, http://www.marcus-biel.com/
Marcus Biel, Software Craftsman
http://www.marcus-biel.com

Doubly Linked List
23 3 17 9 42
In the previous episode I introduced you to the Linked List data structure.

Doubly Linked List
23 3 17 9 42
As the name implies, the Java class LinkedList is called LinkedList
because internally it is based on a Doubly Linked List.

Concept vs. Implementation
So what is the difference between the LinkedList data structure
and
the class java.util.LinkedList?

As an analogy, think of the abstract concept of a car
and a concrete car.

The Linked List data structure is an abstract concept,
independent of any specific programming language.

The LinkedList Java class is a concrete implementation
of this abstract concept.

java.util.LinkedList
Implements
Extends
LinkedList
So in this tutorial, I will focus on one specific
Linked List implementation,
the java.util.LinkedList class.

Implements
Extends
<<interface>>
List
LinkedList
Among other interfaces,
LinkedList implements the java.util.List interface.

Implements
Extends
<<interface>>
List
LinkedList
You can have duplicate elements in a List and
you can go from element to element in the same order
as the elements were inserted.

ArrayList vs. LinkedList
Implements
Extends
<<interface>>
List
ArrayList LinkedList
In a previous tutorial,
I introduced you to the java.util.ArrayList class.

Implements
Extends
<<interface>>
List
ArrayList LinkedList
As you can see, both classes implement the List interface,
which makes them somewhat similar.
So what’s the difference between ArrayList and LinkedList?

0 1 2 3 4
23 3 17 9 42
First of all, ArrayList is based on an Array data structure,

0 1 2 3 4
23 3 17 9 42
23 3 17 9 42
while LinkedList is based on a
Doubly Linked List data structure.

0 1 2 3 4
23 3 17 9 42
23 3 17 9 42
Compared to an ArrayList,
the Doubly Liked List data structure of the LinkedList class
allows more efficient insertion and
removal of elements at any position within the List.

23 3 17 9 42
Therefore,
as an implementation of the List interface prefer
LinkedList over ArrayList
if your main use is to
add or remove elements at random positions in the List.

0 1 2 3 4
23 3 17 9 42
Otherwise, ArrayList might be a better choice,
because storing elements in an array consumes less memory
and generally gives faster access times.

Implements
Extends
<<interface>>
Collection
<<interface>>
List
<<interface>>
Queue
LinkedList
<<interface>>
Deque
ArrayList
Besides the different data structures of
ArrayList and LinkedList
LinkedList also implements the Queue and the Deque interfaces
which gives it some additional functionality over ArrayList.

Implements
Extends
<<interface>>
Collection
<<interface>>
List
<<interface>>
Queue
LinkedList
<<interface>>
Deque
ArrayList
In conclusion, there is no overall winner between
ArrayList and LinkedList.
Your specific requirements will determine which class to use.

LinkedList
Implements
Extends
<<interface>>
Collection
<<interface>>
List
<<interface>>
Queue
LinkedList
<<interface>>
Deque
Let’s put ArrayList aside for now and
have an in-depth look at the LinkedList implementation.

LinkedList
Here is a simplified code excerpt from the
java.util.LinkedList class.
package java.util;
public class LinkedList<E> implements List<E>,Deque<E>{
private Node<E> first;
private Node<E> last;
public E get(int index) {…}
public boolean add(E e) {…}
public E remove(int index) {…}
[…]
}

package java.util;
[…]
}
LinkedList
I don’t expect you to fully grasp every detail of the code,
I just want to show you that
LinkedList is a normal Java class
which anyone could have written,
given enough time and knowledge.

package java.util;
[…]
}
LinkedList
The real source code is available online.
After finishing this presentation,
I recommend that you take a look at it for yourself.

package java.util;
[…]
}
LinkedList
So, as you can see, LinkedList implements the
List, Queue and Deque interfaces,
as Deque extends the Queue interface.

package java.util;
[…]
}
LinkedList
Next you can see that the LinkedList class
has a reference to the first and the last elements of the list.

package java.util;
[…]
}
LinkedList
Finally, you can see that the class has functions like-
get, add or remove
to access, insert or delete elements from the list.

Doubly Linked List
23 3 17 9 42
As we just saw in the code,
the LinkedList class has a reference to the first
and last elements of the list,
shown as red arrows in this slide.

Doubly Linked List
23 3 17 9 42
Every single element in a Doubly Linked List has a reference to
its previous and next elements
as well as a reference to an item,
simplified as a number within a yellow box on this slide.

public class Node<E> {
private E item;
private Node<E> previous;
private Node<E> next;
public Node(E element, Node<E> previous, Node<E> next) {
this.item = element;
this.next = next;
this.previous = previous;
}
}
Node
Here you see a code excerpt of a Node.
It has private members for the item it holds,
and for the previous and next Node in the list.

package java.util;
[…]
}
LinkedList
As a user of the Collections class LinkedList,
you never directly access the Nodes.

package java.util;
[…]
}
LinkedList
Instead you use the public methods of the LinkedList class
that internally operate on the private Node members.

java.util.List
<<interface>>
List
LinkedList
In my tutorial about ArrayList ,
I introduced you to the methods of the List interface,
so I won’t mention about those methods again.

java.util.Queue
<<interface>>
Queue
LinkedList
Instead, let’s go on and look at the methods of the
Queue interface implemented by LinkedList.

Operations on a Queue
end (tail) front (head)23 3 17 9 42
From a high level perspective,
the Queue interface consists of three simple operations:

add element
retrieve element
retrieve and remove element
add an element to the end of the Queue

add element
retrieve element
retrieve an element from the front of the Queue,
without removing it.

add element
retrieve element
but of course the operation returns a reference to the object
and does not copy it.

add element
retrieve element
Okay. Finally you can retrieve and remove
an element from the front of the Queue.

Specific Events on a Queue
In the lifetime of a Queue, there are special situations,

?
like trying to remove an element…
from an empty Queue

or trying to add an element to a Queue that has a limited capacity
and is currently full.
23 3 17 9 42 39 25 11 16 20 34

return special value
throw Exception
Depending on your specific implementation,
this might be an expected situation and
you need a method that returns null or false in this case.

return special value
throw Exception
Alternatively this might be an unexpected situation and
you need a method that throws an Exception in this case.

java.util.Queue
Throws Exception Returns Special Value
Add add Offer
Retrieve element Peek
Retrieve & Remove Remove Poll
The Queue interface offers each of its operations in two flavours –
one method that will throw an Exception, and
one that will return a special value in certain cases.
let’s look at this in more detail.

Add elements
boolean add(E e)
boolean offer(E e)
A Queue allows to add elements to the end of the Queue.

Add elements
boolean add(E e)
boolean offer(E e)
“add” will throw an Exception when the Queue is full,
while “offer” will return false in this case.

Add elements
boolean add(E e)
boolean offer(E e)
LinkedList, like most Queue implementations,
has an unlimited capacity, so it will never be full.

Add elements
boolean add(E e)
boolean offer(E e)
ArrayBlockingQueue on the other hand is a
Queue implementation that has a limited capacity.

Retrieve elements
E element()
E peek()
Next, “element” and “peek”
allow you to retrieve an element from the front of the Queue,
without removing it.

Retrieve elements
E element()
E peek()
If the Queue is empty,
the element function will throw an Exception,
while peek() will return false.

Retrieve & remove elements
E remove()
E poll()
Finally you can retrieve and remove an element
from the front of the Queue.
If the Queue is empty, remove will throw an Exception,
while poll will return false.

java.util.Deque
<<interface>>
Deque
LinkedList
Okay, now we will look at some methods of the Deque interface,
as implemented by LinkedList.

java.util.Deque
<<interface>>
Deque
LinkedList
Deque is the short form of “Double Ended Queue”

java.util.Deque
<<interface>>
Deque
LinkedList
so it is a Queue that can be accessed from either end.

java.util.Deque
throws Exception returns special value
Add addFirst addLast offerFirst offerLast
Retrieve getFirst getLast peekFirst peekFirst
Retrieve & Remove
removeFirst removeLas
t
pollFirst pollLast
Just like a Queue, a Deque allows adding, retrieving
and - retrieving and removing - an element.

java.util.Deque
Retrieve & Remove
t
pollFirst pollLast
But as it can be accessed from either end,
the Queue methods we saw before now exist in two variations –
one for the first and one for the last element in the Deque.

java.util.Deque
Retrieve & Remove
t
pollFirst pollLast
Again, let’s look at this in more detail.

Add elements
You can add elements to both ends of the Deque.

Add elements
void addFirst(E e)
Just like the add method of the Queue interface, addFirst

Add elements
void addFirst(E e)
void addLast(E e)
and addLast will throw an Exception when the Deque is full.

Add elements
3 17 9
42
boolean offerFirst(E e)
“offerFirst”…

Add elements
3 17 9
22
boolean offerLast(E e)
…and “offerLast” will return false
instead of throwing an Exception.

Add elements
Please keep in mind that LinkedList has an unlimited capacity,
so it will never be full.

Add elements
LinkedBlockingDeque on the other hand is a
Deque implementation-that may have a limited capacity.
Okay, let’s go on.

Retrieve elements
You can retrieve elements from both ends of the Deque,
without removing them.

Retrieve elements
E getFirst()
“getFirst”…

Retrieve elements
E getFirst()
E getLast()
and “getLast” will throw an Exception when the Queue is empty,

Retrieve elements
E peekFirst()
while “peekFirst”

Retrieve elements
E peekFirst()
E peekLast()
and “peekLast” will return false in this case.

Retrieve elements
Finally,
you can retrieve and remove elements from both ends of the Deque.

Retrieve elements
E removeFirst()
“removeFirst”

E removeFirst()
E removeLast()
and “removeLast” will throw
an Exception when the Queue is empty,

E pollFirst()
while pollFirst

E pollFirst()
E pollLast()
and pollLast will return false in this case.

Stack
Okay. Now on to a completely different topic.
The Deque interface also supports
the methods of the Stack data structure,
“push” “peek” and “pop”.

Stack
Therefore java.util.LinkedList can also be used as Stack.

Stack
A Stack is a very simple data structure,
that can only be accessed from the top.
As an analogy, think of a stack of books.

Stack
boolean push (E e)
“push” adds an element to the top of the Stack.

Stack
boolean push (E e)
It is equivalent to the “addFirst” method.

Stack
E peek()
“peek” retrieves
but does not remove an element from the top of the Stack.

Stack
E peek()
It is equivalent to the “peekFirst” method.

Stack
E pop()
“pop” retrieves and removes an element from the top of the Stack.

Stack
E pop()
It is equivalent to the “removeFirst” method.

LinkedList vs Arraylist- an in depth look at java.util.LinkedList

More Related Content

What's hot (20)

Viewers also liked (8)

Similar to LinkedList vs Arraylist- an in depth look at java.util.LinkedList (20)

Recently uploaded (20)

LinkedList vs Arraylist- an in depth look at java.util.LinkedList

Editor's Notes