介绍
众所周知ArrayList底层数据结构是数组，但是数组有个缺点，虽然查询快，但是增删改会慢因为数组是在连续的位置上面储存对象的应用。当我们删除某一个元素的时候在他后面的元素的索引都会左移，导致开销会很大。所以LinkedList应运而生。
LinkedList底层数据结构
链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。
链表可分为单向链表和双向链表。
一个单向链表包含两个值: 当前节点的值和一个指向下一个节点的链接。
一个双向链表有三个整数值: 数值、向后的节点链接、向前的节点链接。
因为LinkedList 采用的是双向链表所以LinkedList 的增加和删除的操作效率更高，而查找和修改的操作效率较低。
应用场景
1.你需要通过循环迭代来访问列表中的某些元素。
2.需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。
类继承关系
应用案例
案例抄自https://www.runoob.com/java/java-linkedlist.htm
添加元素
public class Test {
public static void main(String[] args) {
LinkedList<String> sites = new LinkedList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
System.out.println(sites);
}
}
在列表开头添加元素
public class Test {
public static void main(String[] args) {
LinkedList<String> sites = new LinkedList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
// 使用 addFirst() 在头部添加元素
sites.addFirst("Wiki");
System.out.println(sites);
}
}
在列表结尾添加元素：
public class Test {
public static void main(String[] args) {
LinkedList<String> sites = new LinkedList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
// 使用 addLast() 在尾部添加元素
sites.addLast("Wiki");
System.out.println(sites);
}
}
列表开头移除元素
public class Test {
public static void main(String[] args) {
LinkedList<String> sites = new LinkedList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
// 使用 removeFirst() 移除头部元素
sites.removeFirst();
System.out.println(sites);
}
}
在列表结尾移除元素
public class Test {
public static void main(String[] args) {
LinkedList<String> sites = new LinkedList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
// 使用 removeLast() 移除尾部元素
sites.removeLast();
System.out.println(sites);
}
}
获取列表头部元素
public static void main(String[] args) {
LinkedList<String> sites = new LinkedList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
// 使用 getFirst() 获取头部元素
System.out.println(sites.getFirst());
}
获取列表结尾的元素
public static void main(String[] args) {
LinkedList<String> sites = new LinkedList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
// 使用 getLast() 获取尾部元素
System.out.println(sites.getLast());
}
循环获取元素
public static void main(String[] args) {
LinkedList<String> sites = new LinkedList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
for (int size = sites.size(), i = 0; i < size; i++) {
System.out.println(sites.get(i));
}
}
常用方法
底层原理
无参构造器
public LinkedList() {
}
add
public boolean add(E e) {
linkLast(e);
return true;
}
void linkLast(E e) {
//获取最后一个节点的node (如果刚开始没添加数据的时候last是空)
final Node<E> l = last;
//构建一个node 节点
final Node<E> newNode = new Node<>(l, e, null);
//把刚创建的node节点赋值到最后一个节点
last = newNode;
//如果l == null 表示链表上还没有数据
if (l == null)
//把刚创建的节点当成头节点
first = newNode;
else
//因为l != null 肯定链表上已经有数据了则将刚创建的节点绑定在l节点的下一个节点
l.next = newNode;
size++;
modCount++;
}
创建Node节点
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;
//当前节点的next 节点因为当前节点是新构建的节点他的next节点肯定是空
this.next = next;
//指向当前节点的前一个节点
this.prev = prev;
}
}
get(int index)
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
checkElementIndex(int index)
校验是否超过最大长度限制
private void checkElementIndex(int index) {
if (!isElementIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private boolean isElementIndex(int index) {
return index >= 0 && index < size;
}
获取元素
判断index在链表的哪边。
遍历查找index或者size-index次，找出对应节点。
这里我们知道，相比于数组的直接索引获取，遍历获取节点效率并不高
Node<E> node(int index) {
// assert isElementIndex(index);
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;
}
}
