🚩 Java collection: on LinkedList
📚 1. Use of LinkedList set
✒️ 1.1 simple use of LinkedList set
import java.util.LinkedList;
public class TestDemo {
public static void main(String[] args) {
LinkedList<Integer> list = new LinkedList<>();
list.add(11);
list.add(22);
list.add(33);
list.add(11);
list.add(null);
for (Integer value : list) {
System.out.print(value + " ");
}
}
}
Operation results:
🖊️ 1.2 LinkedList set features
1. The data is in order of insertion
2. Data can be inserted repeatedly
3. null values can be stored
4. The bottom layer adopts the data structure of two-way linked list
📕 2. Study the implementation of LinkedList through JDK source code
📫 2.1 inheritance
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
Class structure diagram:
① LinkedList inherits the AbstractSequentialList abstract class. AbstractSequentialList inherits from AbstractList and implements common methods to facilitate the direct reuse of subclasses.
② LinkedList also implements List, Cloneable and Java io. Serializable interface, which can realize cloning and serialization.
③ deque interface is implemented. This interface is a two terminal Queue interface, which inherits from the Queue interface. Therefore, LinkedList is also the implementation class of the Queue interface, and queues and stacks can be realized with the help of this Queue.
📪 2.2 properties and default values
//Number of valid data
transient int size = 0;
//Head node position
transient Node<E> first;
//Tail node position
transient Node<E> last;
//Node class
private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
From the Node class, we can see that the underlying layer of LinkedList is a data structure of two-way linked list.
📬 2.3 constructor
non-parameter constructor
public LinkedList() {
}
Parameterized constructors parameterized constructors call nonparametric constructors and bulk add functions
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
📭 2.4 common methods source code analysis
📑 2.4.1 add: add element
public boolean add(E e) {
linkLast(e);
return true;
}
void linkLast(E e) {
final Node<E> l = last;
//The new node takes the tail node of the linked list as the precursor, and inserts the new node into the tail of the linked list
final Node<E> newNode = new Node<>(l, e, null);
//Update the tail node and take the new node as the tail node
last = newNode;
if (l == null)
//If the first node is currently inserted, point the head node to the new node. At this time, first = last = newNode
first = newNode;
else
//The current inserted node is not the first node. The next field of the tail node of the original linked list points to the new node
l.next = newNode;
size++;//Number of effective elements + 1
modCount++;
}
📄 2.4.2 remove: delete element
public boolean remove(Object o) {
//Determine whether the deleted element is null
if (o == null) {
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}
//Delete element logic
E unlink(Node<E> x) {
// assert x != null;
final E element = x.item;
final Node<E> next = x.next;
final Node<E> prev = x.prev;
//Determine whether the deleted element is the first element
if (prev == null) {
//The deleted element is the first element, and the header node points to the second element
first = next;
} else {
//The deleted element is not the first element
//The successor of the previous node of the deleted element points to the next node of the deleted element
//The precursor of the deleted element is set to null
prev.next = next;
x.prev = null;
}
//Determine whether the deleted element is the last element
if (next == null) {
//The deleted element is the last element, and the tail node points to its previous node
last = prev;
} else {
//The deleted element is not the last element
//The precursor of the last node of the deleted element points to the previous node of the deleted element
//The successor of the deleted element is set to null
next.prev = prev;
x.next = null;
}
//Set the item of the deleted node to null
x.item = null;
size--;//Number of valid elements - 1
modCount++;
return element;
}
The precursor, successor and item of the Node are set to null to facilitate Node recycling
📃 2.4.3 get: get elements
public E get(int index) {
//Check the validity of the subscript
checkElementIndex(index);
return node(index).item;
}
private void checkElementIndex(int index) {
//If the subscript is illegal, a subscript out of bounds exception is thrown
if (!isElementIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
//Check whether the subscript is between 0 and the limited range of size - 1
private boolean isElementIndex(int index) {
return index >= 0 && index < size;
}
Node<E> node(int index) {
// assert isElementIndex(index);
//Use the binary search method to find elements
//If the subscript is in the first half of size/2, look from front to back
//If the subscript is in the second half of size/2, look from back to front
if (index < (size >> 1)) {
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
🃏 3. Comparison between ArrayList and LinkedList
| Bottom structure | Efficiency of addition and deletion | Efficiency of modification | |
|---|---|---|---|
| ArrayList | Variable array | Lower array expansion | higher |
| LinkedList | Bidirectional linked list | Higher, added through linked list | Lower |
How to select ArrayList and LinkedList:
1. Select ArrayList if we have many operations to change the query
2. If we have many additions and deletions, select LinkedList
3. Generally speaking, in the program, 80% ~ 90% are queries, so ArrayList will be selected in most cases
4. In a project, it can be selected flexibly according to the business. One module uses ArrayList and the other module uses LinkedList