LinkedList
源码探究
- 存在包:
存在于java.util包中。 - 继承关系:
class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
LinkedList继承AbstractSequentialList,父类中对部分接口进行实现。实现了List接口、Deque接口、Cloneable接口提供的方法,Serializable说明该类能够被序列化 ,能够被克隆、序列化。
- 底层数据结构:
底层数据结构 —》双向链表。 - 基本属性:
int size = 0;//集合中元素个数
Node<E> first;//头结点
Node<E> last;//尾结点
//数据类型 Node
- 构造函数:
public LinkedList() {
} //无参构造
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
} //有参构造
- CRUD方法研究(增删改查):
(1)add()添加元素,默认尾插,插入有序:
public boolean add(E e) {
linkLast(e);
return true;
}
void linkLast(E e) {
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null);//创建一个新的节点,尾插法,前驱节点为last,后继节点为Null
last = newNode;//把新的节点赋给last
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
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;
}
}
get():获取指定索引的元素
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
private void checkElementIndex(int index) {
if (!isElementIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private boolean isElementIndex(int index) {
return index >= 0 && index < size;
}
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;
}
}
remove():删除指定索引的元素
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
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;
//前驱prev分两种情况:一种是first结点,一种是非first结点
if (prev == null) {//当前结点为头结点first
first = next;
} else {//头结点以外的其他结点
prev.next = next;
x.prev = null;
}
//后继next:一种为last结点,一种是非last结点
if (next == null) {//当前结点为last结点
last = prev;
} else {
next.prev = prev;
x.next = null;
}
//将元素变为null
x.item = null;
size--;
modCount++;
return element;
}
//判断元素是否为null,进行不同的判等处理
//删除元素从前往后进行,重复性元素直接删除第一个结点
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;
}
Iterator():
public Iterator<E> descendingIterator() {
return new DescendingIterator();
}
private class DescendingIterator implements Iterator<E> {
private final ListItr itr = new ListItr(size());
public boolean hasNext() {
return itr.hasPrevious();
}
public E next() {
return itr.previous();
}
public void remove() {
itr.remove();
}
}
public boolean hasPrevious() {
return nextIndex > 0;
}
public E previous() {
checkForComodification();
if (!hasPrevious())
throw new NoSuchElementException();
lastReturned = next = (next == null) ? last : next.prev;
nextIndex--;
return lastReturned.item;
}
public void remove() {
checkForComodification();
if (lastReturned == null)
throw new IllegalStateException();
Node<E> lastNext = lastReturned.next;
unlink(lastReturned);
if (next == lastReturned)
next = lastNext;
else
nextIndex--;
lastReturned = null;
expectedModCount++;
}
总结LinkedList特点:
1.有序性: 数据按照插入有序;
2. NULL值: 可存储null值;
3. 重复性:可重复存储元素;