# LinkList source code analysis

@auther worry free youth

@creatTime 2020/07/16

## 1, Foreword

This time, let's take a look at the second of the common lists - LinkedList. When analyzing ArrayList earlier, we mentioned that LinkedList is a linked List structure. In fact, it is similar to the LinkedHashMap structure we talked about when analyzing map, but it is much simpler. Let's take a look at its specific structure in detail today, And the scenarios used.

## 2, LinkedList structure overview

Before looking at the specific structure, let's take a look at its inheritance relationship:

Unlike ArrayList, LinkedList inherits AbstractSequentialList. It can be seen from the word Sequential that the abstract class implements the structure of Sequential access, because it can be inferred that it may be related to the linked list.

In addition, it is worth noting that the Deque interface, the origin of the class name is "double ended queue", that is, a two-way queue, that is, queue operations can be performed from the head and tail.

So to sum up, we can know that LinkedList is a two-way linked list data structure:

LinkedList can be traversed from the head and tail.

## 3, LinkedList source code reading

### 3.1 LinkedList member variable

// Number of elements in list transient int size = 0; // Head node of linked list transient Node<E> first; // Tail node of linked list transient Node<E> last;

The internal class Node called Node is the key to implementing the linked list:

private static class Node<E> { // Actual stored elements E item; // Last element Node<E> next; // Previous element Node<E> prev; // The order of constructor elements is before, after and after. It's like waiting in line Node(Node<E> prev, E element, Node<E> next) { this.item = element; this.next = next; this.prev = prev; } }

### 3.2 LinkedList construction method

Because the linked list structure is adopted, LinkedList does not have the construction method of specified capacity like ArrayList, so here we mainly talk about the construction method of pass through set.

public LinkedList(Collection<? extends E> c) { // Call the construction method without parameters, but there is nothing in it this(); // Add the elements in the c set to the list addAll(c); }

Considering that addall (collection <? Extensions E > C) is a public method, consider adding elements at the end of the linked list when elements already exist in the list:

public boolean addAll(Collection<? extends E> c) { return addAll(size, c); } public boolean addAll(int index, Collection<? extends E> c) { // Check whether the index is correct, i.e. between 0-size checkPositionIndex(index); // Convert collection to array Object[] a = c.toArray(); int numNew = a.length; if (numNew == 0) return false; // pred is the preceding element and succ is the successor element Node<E> pred, succ; // Initialize pred and succ. if (index == size) { // index == size, indicating that the position of the element to be inserted is at the end of the linked list. The post element is null, and the previous element is last succ = null; pred = last; // index != size, indicating that it is inserted in the middle of the linked list. pred is the prev of the original index, and succ is the original element } else { succ = node(index); pred = succ.prev; } // Find out the relationship between the front and back elements, that is, traverse the array and add them one by one for (Object o : a) { @SuppressWarnings("unchecked") E e = (E) o; Node<E> newNode = new Node<>(pred, e, null); if (pred == null) first = newNode; else pred.next = newNode; pred = newNode; } // If the subsequent element is empty, the last element after insertion is prev last if (succ == null) { last = pred; // Otherwise, the relationship between the last element and the previous element is maintained } else { pred.next = succ; succ.prev = pred; } size += numNew; modCount++; return true; }

The logic for traversing the Collection and inserting the linked list should be very clear:

- Call the Node's construction method according to the pre self post relationship for initialization.
- Since the previous element pred may be empty (constructor call), if it is judged that pred is empty, the initialized element is the header node
- Otherwise, maintain the direct relationship between pred and the new node newNode.
- Use the new node as pred to prepare for the next element insertion

In addition, as a two-way linked list, the node(int index) method also uses this feature to traverse faster:

Node<E> node(int index) { // If the index is in the first half of the linked list, the traversal starts from the head node if (index < (size >> 1)) { Node<E> x = first; for (int i = 0; i < index; i++) x = x.next; return x; // If the index is in the second half of the linked list, it will traverse from the tail node } else { Node<E> x = last; for (int i = size - 1; i > index; i--) x = x.prev; return x; } }

The elements in the first half are traversed from scratch, and the elements in the second half are traversed from the tail.

### 3.3 important methods of LinkedList

#### 3.3.1 add(E e)

First, let's talk about the specific idea. As a linked list structure, adding elements is to insert elements at the end of the linked list. In this process, we should consider:

- What should I do if the last element is null

public boolean add(E e) { linkLast(e); return true; } void linkLast(E e) { // Record last node final Node<E> l = last; // Initialize a new node final Node<E> newNode = new Node<>(l, e, null); last = newNode; // Judge the last node if (l == null) first = newNode; else l.next = newNode; // Number of elements + 1 size++; // Add modification times modCount++; }

The general processing is similar to linkNodeLast of LinkedHashMap.

#### 3.3.2 remove(Object o)

Similarly, let's talk about the specific treatment ideas first:

- Since the inserted element may be null, judge O. otherwise, null pointer exceptions will be reported whether o is null or the element is null during traversal
- After finding the element, re maintain the relationship between the front and back elements, taking into account whether the element is at the beginning and end

public boolean remove(Object o) { // Judgment of whether it is empty if (o == null) { // Traverse the linked list to find elements for (Node<E> x = first; x != null; x = x.next) { if (x.item == null) { // Once found, re maintain the relationship between the elements before and after deleting the element unlink(x); return true; } } // Same as above } else { for (Node<E> x = first; x != null; x = x.next) { if (o.equals(x.item)) { unlink(x); return true; } } } return false; }

When unlink ing, you need to consider the second point mentioned earlier:

E unlink(Node<E> x) { final E element = x.item; // Elements before and after recording final Node<E> next = x.next; final Node<E> prev = x.prev; // If prev is null, it means that x node is the first node. After deletion, next is the first node if (prev == null) { first = next; // Otherwise, the next element of prev is the next element of x } else { prev.next = next; // Set to null to facilitate prev's GC x.prev = null; } // ditto if (next == null) { last = prev; } else { next.prev = prev; // Set to null to facilitate the GC of next x.next = null; } // Set to null for GC convenience x.item = null; size--; modCount++; return element; }

#### 3.3.3 listIterator(int index)

Finally, the author makes a brief analysis on the implementation of iterator.

public Iterator<E> iterator() { // Call the method return listiterator() in AbstractList;} public ListIterator<E> listIterator() { return listIterator(0);}

What iterator() calls is actually the listIterator() method. Different implementation classes will implement different methods. In LinkedList, what is it like:

public ListIterator<E> listIterator(int index) { checkPositionIndex(index); return new ListItr(index);}

The call returns the ListItr object.

private class ListItr implements ListIterator<E> { // Record the last returned element private node < E > lastreturned// Record the next element private node < E > next; private int nextIndex; // It is used to judge whether there are changes to elements during iteration. Private int expectedmodcount = modcount; Listitr (int index) {/ / initialize next to return next = (index = = size)? Null in the next method: node (index); nextindex = index;} public boolean hasNext() { return nextIndex < size; } Public e next() {/ / judge whether there is any change to the element. If so, throw an exception checkforcomodification(); if (! Hasnext()) throw new nosuchelementexception(); // The next element in next () is the result to be returned lastreturned = next; next = next. next; nextIndex++; return lastReturned. item; } final void checkForComodification() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); }}

From the source code, we can know why we throw exceptions when we modify the collection in the process of iteration. The purpose of doing so is to prevent problems caused by multithreading operating the same collection.

## 4, Usage scenario of LinkedList

As a feature of the linked list structure, LinkedList can ensure its endpoint operations, such as insertion and deletion, which is faster than ArrayList. The reason is very simple. After ArrayList is deleted, the following elements must be moved forward every time (although the copy method is adopted), and LinkedList only needs to maintain the relationship between the front and rear elements again.

Quote from Java programming thought:

The best practice may be to use ArrayList as the default choice. Only when you need to use additional functions (personally understood as the operation of Queue), or when the performance of the program deteriorates due to frequent insertion and deletion from the middle of the table, you can choose LinkedList.

## 5, Summary

For frequent insert and delete operations in the middle of the collection, or when the queue feature needs to be used, we can consider using LinkedList. Finally, thank you for watching. If there is something wrong, please correct it and make progress with you!