一、LinkedList的概述
LinkedList是双向链表实现的ListLinkedList是非线程安全的LinkedList元素允许为null,允许重复元素LinkedList是基于链表实现的,因此插入删除效率高,查找效率低(虽然有一个加速动作)LinkedList是基于链表实现的,因此不存在容量不足的问题,所以没有扩容的方法LinkedList还实现了栈和队列的操作方法,因此也可以作为栈、队列和双端队列来使用
二、LinkedList的分析
LinkedList的存储结构
LinkedList是由双链表的数据结构组成的
public class LinkedList{
// 元素个数transient int size = 0;
/**指向第一个节点的指针不变性:
1. 如果first = null,则last=null
2. 如果first.prev == null,
则first.item != null*/
transient Node<E> first;
/**指向最后一个节点的指针不变性:
1. 如果first = null,则last = null
2. 如果last.next == null,
则last.item != null*/
transient Node<E> last;
private static class Node<E> {
E item;Node<E> next;
// 下一个Node的引用
Node<E> prev;
// 上一个Node的引用
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;}}
/**
创建一个空list
*/
public LinkedList() {}
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
}
2.1添加元素
1.从头部添加
// 从头插入
public void addFirst(E e) {
linkFirst(e);
}
private void linkFirst(E e) {
final Node<E> f = first;
final Node<E> newNode = new Node<>(null, e, f);
first = newNode;
if (f == null)
// 当前List中没有元素,
size=0
last = newNode;
else
f.prev = newNode;
size++;modCount++;
}
2.从尾部添加
public boolean add(E e) {
linkLast(e);return true;
}
public void addLast(E e) {
linkLast(e);
}
void linkLast(E e) {
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
if (l == null){
// 当前List中没有元素,
size=0;
first = newNode;
}else{
l.next = newNode;
size++;
modCount++;
}
}
2.2删除节点**
1.从头部删除
// 移除首节点,并返回该节点的元素值
public E remove() {
return removeFirst();
}
public E removeFirst() {
final Node<E> f = first; if (f == null)throw new NoSuchElementException(); return unlinkFirst(f);}
// 删除首节点f
private E unlinkFirst(Node<E> f) {
final E element = f.item;
final Node<E> next = f.next;
f.item = null;f.next = null;
// help GC first = next;if (next == null)
// size=1 last = null;
elsenext.prev = null;
size--;modCount++;
return element;}
2.从尾部移除
public E removeLast() {
final Node<E> l = last;
if (l == null)throw new NoSuchElementException();
return unlinkLast(l);}
private E unlinkLast(Node<E> l) {
final E element = l.item;
final Node<E> prev = l.prev;
l.item = null;l.prev = null;
// help GC last = prev;if (prev == null)
// size=1 first = null;elseprev.next = null;
size--;modCount++; return element;}
3.根据索引移除
public E remove(int index) {
checkElementIndex(index);// 检查索引index范围
return unlink(node(index));
}
E unlink(Node<E> x) {
final E element = x.item;
final Node<E> next = x.next;
final Node<E> prev = x.prev;
if (prev == null) {
// x为首节点
first = next;}
else {
prev.next = next; x.prev = null;}if (next == null) {
// x为尾节点last = prev;}
else {
next.prev = prev; x.next = null;}x.item = null; size--; modCount++;
return element;}
2.3获取节点数据
1.获取头部数据
// 获取首节点的数据
public E getFirst() {final Node f = first; if (f == null)throw new NoSuchElementException(); return f.item;}
2.获取尾部数据
// 获取尾节点的数据
public E getLast() {
final Node<E> l = last; if (l == null)throw new NoSuchElementException(); return l.item;}
3.根据索引获取节点数据
// 获取索引对应节点的数据
public E get(int index) {
checkElementIndex(index);
return node(index).item;}
// 类似折半查找
Node node(int index) {if (index < (size >> 1)) {// 从前半部分查找Node x = first;for (int i = 0; i < index; i++) x = x.next;return x;} else {// 从后半部分查找Node x = last;for (int i = size - 1; i > index; i–) x = x.prev;return x;}}
三LinkedList的使用
1.获取链表的第一个和最后一个元素
import java.util.LinkedList;
public class LinkedListTest{
public static void main(String[] args) {
LinkedList<String> lList = new LinkedList<String>();
lList.add("1");
lList.add("2");
lList.add("3");
lList.add("4");
lList.add("5");
System.out.println("链表的第一个元素是 : " + lList.getFirst());
System.out.println("链表最后一个元素是 : " + lList.getLast());
}
}
2.删除链表的第一个和最后一个元素
list.removeFirst();
list.removeLast();
3.使用链表实现栈效果
import java.util.LinkedList;
public class MainClass {
public static void main(String[] args) {
StackL stack = new StackL();
for (int i = 0; i < 10; i++)
stack.push(i);
System.out.println(stack.top());
System.out.println(stack.top());
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.pop());
}
}
class StackL {
private LinkedList list = new LinkedList();
public void push(Object v) {
list.addFirst(v);
}
public Object top() {
return list.getFirst();
}
public Object pop() {
return list.removeFirst();
}
}
4.使用链表来实现队列效果
import java.util.LinkedList;
public class MainClass {
public static void main(String[] args) {
Queue queue = new Queue();
for (int i = 0; i < 10; i++)
queue.put(Integer.toString(i));
while (!queue.isEmpty())
System.out.println(queue.get());
}
}
class Queue {
private LinkedList list = new LinkedList();
public void put(Object v) {
list.addFirst(v);
}
public Object get() {
return list.removeLast();
}
public boolean isEmpty() {
return list.isEmpty();
}
}
5.根据范围删除列表元素
import java.util.LinkedList;
public class Main {
public static void main(String[] args) {
LinkedList<String> lList = new LinkedList<String>();
lList.add("1");
lList.add("2");
lList.add("3");
lList.add("4");
lList.add("5");
System.out.println(lList);
lList.subList(2, 5).clear();
System.out.println(lList);
}
}
6.查找元素位置
import java.util.LinkedList;
public class Main {
public static void main(String[] args) {
LinkedList<String> lList = new LinkedList<String>();
lList.add("1");
lList.add("2");
lList.add("3");
lList.add("4");
lList.add("5");
lList.add("2");
System.out.println(lList.indexOf("2"));
System.out.println(lList.lastIndexOf("2"));
}
}
7.遍历方式
-
for循环
for (int i = 0; i < linkedList.size(); i++) { System.out.println(linkedList.get(i)); }
-
自动增强for循环
for (String s : linkedList) { System.out.println(s); }
-
迭代器遍历
Iterator<String> it = linkedList.iterator(); while (it.hasNext()) { System.out.println(it.next()); }
四、总结:LinkedList和ArrayList的比较
- 顺序插入速度ArrayList会比较快,因为ArrayList是基于数组实现的,数组是事先new好的,只要往指定位置 塞一个数据就好了
- 2.LinkedList则不同,每次顺序插入的时候LinkedList将new一个对象出来,如果对象比较大,那么new的时间 势必会长一点,再加上一些引用赋值的操作,所以顺序插入LinkedList必然慢于ArrayList
- ArrayList的遍历效率会比LinkedList的遍历效率高一些
- LinkedList做插入、删除的时候,慢在寻址,快在只需要改变前后Node的引用地址
ArrayList做插入、删除的时候,慢在数组元素的批量copy,快在寻址 - 如果确定插入、删除的元素是在前半段,那么就使用LinkedList
如果确定插入、删除的元素在比较靠后的位置,那么可以考虑使用ArrayList
如果不能确定插入、删除是在哪儿呢?建议使用LinkedList, - LinkedList整体插入、删除的执行效率比较稳定,没有ArrayList这种越往后越快的情况,插入元素的时候,弄得不好ArrayList就要进行一次扩容,而ArrayList底层数组扩容是一个既消 耗时间又消耗空间的操作