目录
一、LinkedList的全面说明
- LinkedList底层实现了双向链表和双端队列的特点
- 可以添加任意元素(元素可以重复)，包括null
- 线程不安全，没有实现同步和互斥
二、LinkedList的底层操作机制
- LinkedList底层维护了一个双向链表
- LinkedList中维护了两个属性first和last，分别指向首节点和尾节点
- 每个节点(Node对象)，里面又维护了prev、next、item三个属性，其中通过prev指向前一个，通过next指向后一个节点。最终实现双向链表
- 所以LinkedList元素的添加和删除 ，不是通过数组完成的，相对来说效率较高
(一)LinkedList添加结点源码
java
1. LinkedList linkedList = new LinkedList();
public LinkedList() {}
2. 这时 linkeList 的属性 first = null last = null
3. 执行 添加
public boolean add(E e) {
linkLast(e);
return true;
}
4.将新的结点，加入到双向链表的最后
void linkLast(E e) {
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}(二)LinkedList删除结点源码
java
linkedList.remove(); // 这里默认删除的是第一个结点
1. 执行 removeFirst
public E remove() {
return removeFirst();
}
2. 执行
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
3. 执行 unlinkFirst, 将 f 指向的双向链表的第一个结点拿掉
private E unlinkFirst(Node<E> f) {
// assert f == first && f != null;
final E element = f.item;
final Node<E> next = f.next;
f.item = null;
f.next = null; // help GC
first = next;
if (next == null)
last = null;
else
next.prev = null;
size--;
modCount++;
return element;
}三、LinkedList常用方法
因为LinkedList也继承了Collection和List，所以List的方法也适用于LinkedList。
- add()
- remove() // 默认删除第一个结点
- removeFirst()
- removeLast()
- set(索引值,插入的元素)
- get(索引值)
java
public static void main(String[] args) {
LinkedList linkedList = new LinkedList();
linkedList.add(1);
linkedList.add(2);
linkedList.add(3);
linkedList.add("");
linkedList.add(" ");
linkedList.add(' ');
linkedList.add(null);
linkedList.add(null);
System.out.println("linkedList=" + linkedList);
// linkedList=[1, 2, 3, , , , null, null]
// remove默认删除第一个结点
linkedList.remove();
System.out.println("linkedList=" + linkedList);
// linkedList=[2, 3, , , , null, null]
// 修改某个结点对象
linkedList.set(1, 999);
System.out.println("linkedList=" + linkedList);
// linkedList=[2, 999, , , , null, null]
// 得到某个结点对象
// get(1) 是得到双向链表的第二个对象
Object o = linkedList.get(1);
System.out.println(o); // 999
// 因为LinkedList 是 实现了List接口, 遍历方式
System.out.println("===LinkeList遍历迭代器====");
Iterator iterator = linkedList.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println("next=" + next);
}
// next=2
// next=999
// next=
// next=
// next=
// next=null
// next=null
System.out.println("===LinkeList遍历增强for====");
for (Object o1 : linkedList) {
System.out.println("o1=" + o1);
}
// next=2
// next=999
// next=
// next=
// next=
// next=null
// next=null
System.out.println("===LinkeList遍历普通for====");
for (int i = 0; i < linkedList.size(); i++) {
System.out.println(linkedList.get(i));
}
// 2
// 999
//
//
//
// null
// null
}四、ArrayList与LinkedList的选择
| 底层结构 | 增删的效率 | 改查的效率 | |
|---|---|---|---|
| ArrayList | 可变数组 | 较低；底层依赖数组扩容 | 较高；根据数组索引查找 |
| LinkedList | 双向链表 | 较高；底层通过链表追加 | 较低；在链表中从头到尾遍历 |
如何选择ArrayList与LinkedList：
- 如果改查的操作多，选择ArrayList
- 如果增删的操作多，选择LinkedList
- 一般来说，80%-90%都是查询，因此大部分情况下会选择ArrayList
- 根据业务灵活选择，也可能一个模块使用的是ArrayList，另一个模块使用LinkedList。