LinkedList
类定义
出现于JDK1.2版本,为list的实现类,是有序可重复的集合,为双向链表实现,查询慢,增删快
/**
* @since 1.2
* @param <E> the type of elements held in this collection
*/
public class LinkedList<E> extends AbstractSequential List<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable{}
变量
//元素个数
transient int size = 0;
//链表头部
transient Node<E> first;
//链表尾部
transient Node<E> last;
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;
this.next = next;
this.prev = prev;
}
}
构造器
1.无参构造
2.将其他集合作为参数传递将来,采用尾插的方式,将元素插入链表,
- 首先会判断如果插入的位置小于0,或者大于链表中元素个数,则抛异常,
- 否则将参数集合转化为Onject数组,判断数组长度如果该数组长度为0,说明参数集合为空,返回false,插入失败
- 如果该数组长度不为0,将前继节点设为原来的last节点;后继节点设为null
- 遍历数据,将数据插入,首先创建新节点,如果头节点为空,则将插入的数据设为头节点,否则将数据插入链表末尾,将尾节点设置为新创建的节点
- 如果是从尾部开始插入的,则把last置为最后一个插入的元素 ,如果不是从尾部插入的,则把尾部的数据和之前的节点连起来
- 最后修改链表长度,并修改次数加1
public LinkedList() {
}
//将其他集合作为参数传递将来
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
public boolean addAll(Collection<? extends E> c) {
//这里为尾插
return addAll(size, c);
}
public boolean addAll(int index, Collection<? extends E> c) {
//如果索引小于0,或者大于链表中元素个数,则抛异常
checkPositionIndex(index);
//将参数集合转化为Onject数组
Object[] a = c.toArray();
int numNew = a.length;
//如果该数组长度为0,说明参数集合为空,返回false
if (numNew == 0)
return false;
Node<E> pred, succ;
if (index == size) {
// 从尾部添加的情况:前继节点是原来的last节点;后继节点是null
succ = null;
pred = last;
} else {
// 从指定位置(非尾部)添加的情况:前继节点就是index位置的节点,后继节点是index位置的节点的前一个节点
succ = node(index);
pred = succ.prev;
}
//遍历数据,将数据插入
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 (succ == null) {
// 如果是从尾部开始插入的,则把last置为最后一个插入的元素
last = pred;
} else {
// 如果不是从尾部插入的,则把尾部的数据和之前的节点连起来
pred.next = succ;
succ.prev = pred;
}
//修改链表长度
size += numNew;
//修改次数加1
modCount++;
//添加成功,返回true
return true;
}
//如果索引小于0,或者大于链表中元素个数,则抛异常
private void checkPositionIndex(int index) {
if (!isPositionIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private boolean isPositionIndex(int index) {
return index >= 0 && index <= size;
}
add
因为是双向链表,所以添加元素的时候相对于ArrayList多了,从头或从尾添加
- addFirst(E e) 从头添加
- addLast(E e) 从尾添加,将尾部节点设置为新添加的元素,如果之前尾部节点为空,则链表尾空,将新添加的元素再设置头节点,不为空,则将之前的尾部节点的下一个节点的引用设置为新添加的元素
- add(int index, E element) 向指定位置添加
public void addFirst(E e) {
linkFirst(e);
}
public void addLast(E e) {
linkLast(e);
}
public boolean add(E e) {
linkLast(e);
return true;
}
//从头添加
private void linkFirst(E e) {
//将链表头部元素取出
final Node<E> f = first;
//新建一个对象,前一个node的引用为空,后一个node的引用为原头部元的引用
final Node<E> newNode = new Node<>(null, e, f);
//再将头部节点设置为新添加的元素
first = newNode;
if (f == null)
//如果为尾部节点为空,则说明之前的链表为空,那么就将尾部节点页设置为新添加的元素
last = newNode;
else
//如果尾部节点不为空,则将之前头节点的前一个node的引用设置为新添加的元素
f.prev = newNode;
size++;
modCount++;
}
//从尾添加,将尾部节点设置为新添加的元素,如果之前尾部节点为空,则链表尾空,将新添加的元素再设置头节点,不为空,则将之前的尾部节点的下一个节点的引用设置为新添加的元素
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++;
}
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
//在 指定节点 前插入一个元素,这里假设 指定节点不为 null
void linkBefore(E e, Node<E> succ) {
// 获取指定节点 succ 前面的一个节点
final Node<E> pred = succ.prev;
//新建一个节点,头部指向 succ 前面的节点,尾部指向 succ 节点,数据为 e
final Node<E> newNode = new Node<>(pred, e, succ);
//让 succ 节点头部指向 新建的节点
succ.prev = newNode;
//如果 succ 前面的节点为空,说明 succ 就是第一个节点,那现在新建的节点就变成第一个节点了
if (pred == null)
first = newNode;
else
//如果前面有节点,让前面的节点
pred.next = newNode;
size++;
modCount++;
}
常用方法
- E getFirst() 返回链表头部元素,如果链表头部元素为空,抛异常
- E getLast() 返回链表尾部元素 ,如果链表未部元素为空,抛异常
- removeFirst() 移除并返回链表头部元素 ,如果链表头部元素为空,抛异常,不为空则将链表头部元素的数据拷贝一份,然后将头部元素赋null
- removeLast() 移除并返回链表尾部元素
- contains(Object o) 是否存在指定的元素
- public int size() 返回集合元素个数
- remove(Object o) 移除指定元素
//返回链表头部元素
public E getFirst() {
final Node<E> f = first;
if (f == null)
//如果链表头部元素为空,抛异常
throw new NoSuchElementException();
return f.item;
}
//返回链表尾部元素
public E getLast() {
final Node<E> l = last;
if (l == null)
//如果链表未部元素为空,抛异常
throw new NoSuchElementException();
return l.item;
}
//移除并返回链表头部元素
public E removeFirst() {
final Node<E> f = first;
if (f == null)
//如果链表头部元素为空,抛异常
throw new NoSuchElementException();
return unlinkFirst(f);
}
private E unlinkFirst(Node<E> f) {
// 将链表头部元素的数据拷贝一份
final E element = f.item;
final Node<E> next = f.next;
//将头部元素赋null
f.item = null;
f.next = null;
//将链表的下一个元素设为链表头部
first = next;
if (next == null)
//如果next为空,说明链表只有一个元素,那么将last也赋null
last = null;
else
//将原本的next设为null
next.prev = null;
size--;
modCount++;
return element;
}
//移除并返回链表尾部元素
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;
last = prev;
if (prev == null)
first = null;
else
prev.next = null;
size--;
modCount++;
return element;
}
//返回链表头部元素
public boolean contains(Object o) {
return indexOf(o) != -1;
}
//返回集合元素个数
public int size() {
return size;
}
//移除指定元素
public boolean remove(Object o) {
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;
}
//移除所有元素
public void clear() {
for (Node<E> x = first; x != null; ) {
Node<E> next = x.next;
x.item = null;
x.next = null;
x.prev = null;
x = next;
}
first = last = null;
size = 0;
modCount++;
}