(1)LinkedList简介
java.lang.Object
↳ java.util.AbstractCollection<E>
↳ java.util.AbstractList<E>
↳ java.util.AbstractSequentialList<E>
↳ java.util.LinkedList<E>
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable {}
LinkedList是一个继承AbstractSequentiaList的双向链表,可以当做栈,队列或者双端队列进行操作
LinkedList实现了List,能对队列进行操作
LinkedList实现了Deque接口,能对双端队列进行操作
LinkedList实现了Serializable,可以支持序列化,它是非同步的
LinkedList的本质是双向链表,它的两个重要成员:header和siz
1)header:双向链表的表头,它是Entry实例。Entry中的成员变量:previous,next,element
2)size:是双向链表的节点的个数
(2)LinkedList重点源码分析
LinkedList源码分析(JDk6)
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
//链表的表头,表头不含有任何数据
private transient Entry<E> header = new Entry<E>(null, null, null);
//linkedList的元素个数
private transient int size = 0;
//创建一个空的Linkedlist
public LinkedList() {
header.next = header.previous = header;
}
//创建一个包含集合的LinkedList
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
//返回链表的第一个元素,为空抛出异常
public E getFirst() {
if (size==0)
throw new NoSuchElementException();
return header.next.element;
}
//返回链表的最后一个元素,为空抛出异常
public E getLast() {
if (size==0)
throw new NoSuchElementException();
return header.previous.element;
}
//删除链表第一个元素,并且返回删除元素
public E removeFirst() {
return remove(header.next);
}
//删除链表的最后一个元素,并返回删除元素
public E removeLast() {
return remove(header.previous);
}
//将元素添加的链表的起始位置
public void addFirst(E e) {
addBefore(e, header.next);
}
//将元素添加到链表的最后
public void addLast(E e) {
addBefore(e, header);
}
//是否包含某个元素
public boolean contains(Object o) {
return indexOf(o) != -1;
}
//返回LinkedList的大小
public int size() {
return size;
}
//将元素添加到LinkedList中,添加到双向链表的末端
public boolean add(E e) {
addBefore(e, header);
return true;
}
//从LinkedList中删除某个元素,先判断元素是否为null,都是从链表头开始查找,并删除元素,返回true
public boolean remove(Object o) {
if (o==null) {
for (Entry<E> e = header.next; e != header; e = e.next) {
if (e.element==null) {
remove(e);
return true;
}
}
} else {
for (Entry<E> e = header.next; e != header; e = e.next) {
if (o.equals(e.element)) {
remove(e);
return true;
}
}
}
return false;
}
//将集合添加到双向链表的末端
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
//从双向链表的index开始,将集合添加的链表中(1.边界判定 2.添加元素)
public boolean addAll(int index, Collection<? extends E> c) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+size);
Object[] a = c.toArray();
int numNew = a.length;
if (numNew==0)
return false;
modCount++;
//设置当前要插入节点的后一节点
Entry<E> successor = (index==size ? header : entry(index));
//设置当前要插入节点的前一节点
Entry<E> predecessor = successor.previous;
//将集合添加到双向链表中
for (int i=0; i<numNew; i++) {
Entry<E> e = new Entry<E>((E)a[i], successor, predecessor);
predecessor.next = e;
predecessor = e;
}
successor.previous = predecessor;
size += numNew;
return true;
}
//清除双向链表,从链表头开始。
public void clear() {
Entry<E> e = header.next;
while (e != header) {
Entry<E> next = e.next;
e.next = e.previous = null;
e.element = null;
e = next;
}
header.next = header.previous = header;
size = 0;
modCount++;
}
//返回index位置对应的节点元素
public E get(int index) {
return entry(index).element;
}
//设置index位置的元素值为element,并返回原值
public E set(int index, E element) {
Entry<E> e = entry(index);
E oldVal = e.element;
e.element = element;
return oldVal;
}
//在index前添加节点,并且节点的值为element
public void add(int index, E element) {
addBefore(element, (index==size ? header : entry(index)));
}
//删除Index位置是元素,并返回
public E remove(int index) {
return remove(entry(index));
}
//获取双向链表中index位置的节点(1.边界判定 2.二分查找)
private Entry<E> entry(int index) {
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+size);
Entry<E> e = header;
if (index < (size >> 1)) {
for (int i = 0; i <= index; i++)
e = e.next;
} else {
for (int i = size; i > index; i--)
e = e.previous;
}
return e;
}
//从前往后查找返回值对象o对应的位置索引
public int indexOf(Object o) {
int index = 0;
if (o==null) {
for (Entry e = header.next; e != header; e = e.next) {
if (e.element==null)
return index;
index++;
}
} else {
for (Entry e = header.next; e != header; e = e.next) {
if (o.equals(e.element))
return index;
index++;
}
}
return -1;
}
//从后往前查找值对象o对应的位置索引
public int lastIndexOf(Object o) {
int index = size;
if (o==null) {
for (Entry e = header.previous; e != header; e = e.previous) {
index--;
if (e.element==null)
return index;
}
} else {
for (Entry e = header.previous; e != header; e = e.previous) {
index--;
if (o.equals(e.element))
return index;
}
}
return -1;
}
//返回第一个节点,如果LinkedList的大小为0,则返回Null
public E peek() {
if (size==0)
return null;
return getFirst();
}
//返回第一个节点,如果LinkedList的大小为0,则抛出异常
public E element() {
return getFirst();
}
//删除并返回第一个节点,如果大小为0,则返回Null
public E poll() {
if (size==0)
return null;
return removeFirst();
}
//删除并返回第一个节点,如果大小为0,抛出异常
public E remove() {
return removeFirst();
}
//将e添加到双向链表尾部
public boolean offer(E e) {
return add(e);
}
//将e添加到双向链表头部
public boolean offerFirst(E e) {
addFirst(e);
return true;
}
//将E添加到双向链表头部
public boolean offerLast(E e) {
addLast(e);
return true;
}
//返回第一个节点,大小为0,返回Null
public E peekFirst() {
if (size==0)
return null;
return getFirst();
}
//返回最后一个节点,大小为0,返回Null
public E peekLast() {
if (size==0)
return null;
return getLast();
}
//删除并返回第一个节点,大小为0,返回Null
public E pollFirst() {
if (size==0)
return null;
return removeFirst();
}
//删除并返回最后一个节点,大小为0,返回Null
public E pollLast() {
if (size==0)
return null;
return removeLast();
}
//将e添加到第一个节点
public void push(E e) {
addFirst(e);
}
//删除并返回第一个节点
public E pop() {
return removeFirst();
}
//从linkedList头往后查找,删除第一个值为o的元素的节点
public boolean removeFirstOccurrence(Object o) {
return remove(o);
}
public boolean removeLastOccurrence(Object o) {
if (o==null) {
for (Entry<E> e = header.previous; e != header; e = e.previous) {
if (e.element==null) {
remove(e);
return true;
}
}
} else {
for (Entry<E> e = header.previous; e != header; e = e.previous) {
if (o.equals(e.element)) {
remove(e);
return true;
}
}
}
return false;
}
//返回index到尾部的全部节点对应的ListIterator对象
public ListIterator<E> listIterator(int index) {
return new ListItr(index);
}
//list迭代器
private class ListItr implements ListIterator<E> {
private Entry<E> lastReturned = header; //上一次返回的节点
private Entry<E> next;//下一个节点
private int nextIndex;//下一个节点对应的索引值
private int expectedModCount = modCount;//期望的改变计数
//构造函数,从in
ListItr(int index) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+size);
if (index < (size >> 1)) {
next = header.next;
for (nextIndex=0; nextIndex<index; nextIndex++)
next = next.next;
} else {
next = header;
for (nextIndex=size; nextIndex>index; nextIndex--)
next = next.previous;
}
}
//是否存在下一个元素
public boolean hasNext() {
return nextIndex != size;
}
//获取下一个元素
public E next() {
checkForComodification();
if (nextIndex == size)
throw new NoSuchElementException();
lastReturned = next;
next = next.next;
nextIndex++;
return lastReturned.element;
}
//是否存在上一个元素
public boolean hasPrevious() {
return nextIndex != 0;
}
//获取上一个元素
public E previous() {
if (nextIndex == 0)
throw new NoSuchElementException();
lastReturned = next = next.previous;
nextIndex--;
checkForComodification();
return lastReturned.element;
}
//获取下一位置索引
public int nextIndex() {
return nextIndex;
}
//获取上一位置索引
public int previousIndex() {
return nextIndex-1;
}
//删除双向链表的当前节点
public void remove() {
checkForComodification();
Entry<E> lastNext = lastReturned.next;
try {
LinkedList.this.remove(lastReturned);
} catch (NoSuchElementException e) {
throw new IllegalStateException();
}
if (next==lastReturned)
next = lastNext;
else
nextIndex--;
lastReturned = header;
expectedModCount++;
}
//设置当前节点为E
public void set(E e) {
if (lastReturned == header)
throw new IllegalStateException();
checkForComodification();
lastReturned.element = e;
}
//将e添加到当前节点前面
public void add(E e) {
checkForComodification();
lastReturned = header;
addBefore(e, next);
nextIndex++;
expectedModCount++;
}
// 判断 “modCount和expectedModCount是否相等”,依次来实现fail-fast机制。
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
// 双向链表的节点所对应的数据结构。
// 包含3部分:上一节点,下一节点,当前节点值。
private static class Entry<E> {
E element;
Entry<E> next;
Entry<E> previous;
Entry(E element, Entry<E> next, Entry<E> previous) {
this.element = element;
this.next = next;
this.previous = previous;
}
}
private Entry<E> addBefore(E e, Entry<E> entry) {
Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
newEntry.previous.next = newEntry;
newEntry.next.previous = newEntry;
size++;
modCount++;
return newEntry;
}
private E remove(Entry<E> e) {
if (e == header)
throw new NoSuchElementException();
E result = e.element;
e.previous.next = e.next;
e.next.previous = e.previous;
e.next = e.previous = null;
e.element = null;
size--;
modCount++;
return result;
}
// 反向迭代器
public Iterator<E> descendingIterator() {
return new DescendingIterator();
}
// 反向迭代器实现类。
private class DescendingIterator implements Iterator {
final ListItr itr = new ListItr(size());
public boolean hasNext() {
return itr.hasPrevious();
}
public E next() {
return itr.previous();
}
public void remove() {
itr.remove();
}
}
//克隆函数,返回LinkedList的克隆对象
public Object clone() {
LinkedList<E> clone = null;
try {
clone = (LinkedList<E>) super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
// Put clone into "virgin" state
clone.header = new Entry<E>(null, null, null);
clone.header.next = clone.header.previous = clone.header;
clone.size = 0;
clone.modCount = 0;
// Initialize clone with our elements
for (Entry<E> e = header.next; e != header; e = e.next)
clone.add(e.element);
return clone;
}
// 返回LinkedList的Object[]数组
public Object[] toArray() {
Object[] result = new Object[size];
int i = 0;
for (Entry<E> e = header.next; e != header; e = e.next)
result[i++] = e.element;
return result;
}
public <T> T[] toArray(T[] a) {
if (a.length < size)
a = (T[])java.lang.reflect.Array.newInstance(
a.getClass().getComponentType(), size);
int i = 0;
Object[] result = a;
for (Entry<E> e = header.next; e != header; e = e.next)
result[i++] = e.element;
if (a.length > size)
a[size] = null;
return a;
}
private static final long serialVersionUID = 876323262645176354L;
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
s.defaultWriteObject();
// Write out size
s.writeInt(size);
// Write out all elements in the proper order.
for (Entry e = header.next; e != header; e = e.next)
s.writeObject(e.element);
}
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
// Read in size
int size = s.readInt();
// Initialize header
header = new Entry<E>(null, null, null);
header.next = header.previous = header;
// Read in all elements in the proper order.
for (int i=0; i<size; i++)
addBefore((E)s.readObject(), header);
}
}
注意:对比过jdk6和jdk8的源码,对于linkedList的改变不是很多,重要的方法基本一致,属性有改动,jdk6只是在Entry header操作,而jdk8我认为为了便于操作和区分,引入node(first和last)这个node的本质和Entry是一样的,都包括前一节点,后一节点,节点值。
LinkedList不存在容量不足的问题,同时它实现了serializable接口,当写入到输出流时,先写入容量,在写入每一个节点的值;当读出输出流先读取容量,在读取每一个元素
(3)LinkedList遍历方式
1)通过迭代器(Iterator)遍历
for(Iterator iter = list.iterator(); iter.hasNext();)
iter.next();
2)通过快速随机访问这个其实我感觉就是for循环,那么就不解释增强for了
int size = list.size();
for (int i=0; i<size; i++) {
list.get(i);
}
3)通过pollFirst/pollLast遍历:
while(list.pollFirst() != null);
while(list.pollLast() != null);
4)通过removeFirst/removeLast遍历:
try {
while(list.removeFirst() != null)
;
} catch (NoSuchElementException e) {
}
try {
while(list.removeLast() != null)
;
} catch (NoSuchElementException e) {
}
通过removeFirst/removeLast效率最高,但是会删除元素数据,如果只是单独的读取不删除数据,可以使用for遍历,通过随机访问太慢慢
LinkedList源码分析(JDk6)
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
//链表的表头,表头不含有任何数据
private transient Entry<E> header = new Entry<E>(null, null, null);
//linkedList的元素个数
private transient int size = 0;
//创建一个空的Linkedlist
public LinkedList() {
header.next = header.previous = header;
}
//创建一个包含集合的LinkedList
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
//返回链表的第一个元素,为空抛出异常
public E getFirst() {
if (size==0)
throw new NoSuchElementException();
return header.next.element;
}
//返回链表的最后一个元素,为空抛出异常
public E getLast() {
if (size==0)
throw new NoSuchElementException();
return header.previous.element;
}
//删除链表第一个元素,并且返回删除元素
public E removeFirst() {
return remove(header.next);
}
//删除链表的最后一个元素,并返回删除元素
public E removeLast() {
return remove(header.previous);
}
//将元素添加的链表的起始位置
public void addFirst(E e) {
addBefore(e, header.next);
}
//将元素添加到链表的最后
public void addLast(E e) {
addBefore(e, header);
}
//是否包含某个元素
public boolean contains(Object o) {
return indexOf(o) != -1;
}
//返回LinkedList的大小
public int size() {
return size;
}
//将元素添加到LinkedList中,添加到双向链表的末端
public boolean add(E e) {
addBefore(e, header);
return true;
}
//从LinkedList中删除某个元素,先判断元素是否为null,都是从链表头开始查找,并删除元素,返回true
public boolean remove(Object o) {
if (o==null) {
for (Entry<E> e = header.next; e != header; e = e.next) {
if (e.element==null) {
remove(e);
return true;
}
}
} else {
for (Entry<E> e = header.next; e != header; e = e.next) {
if (o.equals(e.element)) {
remove(e);
return true;
}
}
}
return false;
}
//将集合添加到双向链表的末端
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
//从双向链表的index开始,将集合添加的链表中(1.边界判定 2.添加元素)
public boolean addAll(int index, Collection<? extends E> c) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+size);
Object[] a = c.toArray();
int numNew = a.length;
if (numNew==0)
return false;
modCount++;
//设置当前要插入节点的后一节点
Entry<E> successor = (index==size ? header : entry(index));
//设置当前要插入节点的前一节点
Entry<E> predecessor = successor.previous;
//将集合添加到双向链表中
for (int i=0; i<numNew; i++) {
Entry<E> e = new Entry<E>((E)a[i], successor, predecessor);
predecessor.next = e;
predecessor = e;
}
successor.previous = predecessor;
size += numNew;
return true;
}
//清除双向链表,从链表头开始。
public void clear() {
Entry<E> e = header.next;
while (e != header) {
Entry<E> next = e.next;
e.next = e.previous = null;
e.element = null;
e = next;
}
header.next = header.previous = header;
size = 0;
modCount++;
}
//返回index位置对应的节点元素
public E get(int index) {
return entry(index).element;
}
//设置index位置的元素值为element,并返回原值
public E set(int index, E element) {
Entry<E> e = entry(index);
E oldVal = e.element;
e.element = element;
return oldVal;
}
//在index前添加节点,并且节点的值为element
public void add(int index, E element) {
addBefore(element, (index==size ? header : entry(index)));
}
//删除Index位置是元素,并返回
public E remove(int index) {
return remove(entry(index));
}
//获取双向链表中index位置的节点(1.边界判定 2.二分查找)
private Entry<E> entry(int index) {
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+size);
Entry<E> e = header;
if (index < (size >> 1)) {
for (int i = 0; i <= index; i++)
e = e.next;
} else {
for (int i = size; i > index; i--)
e = e.previous;
}
return e;
}
//从前往后查找返回值对象o对应的位置索引
public int indexOf(Object o) {
int index = 0;
if (o==null) {
for (Entry e = header.next; e != header; e = e.next) {
if (e.element==null)
return index;
index++;
}
} else {
for (Entry e = header.next; e != header; e = e.next) {
if (o.equals(e.element))
return index;
index++;
}
}
return -1;
}
//从后往前查找值对象o对应的位置索引
public int lastIndexOf(Object o) {
int index = size;
if (o==null) {
for (Entry e = header.previous; e != header; e = e.previous) {
index--;
if (e.element==null)
return index;
}
} else {
for (Entry e = header.previous; e != header; e = e.previous) {
index--;
if (o.equals(e.element))
return index;
}
}
return -1;
}
//返回第一个节点,如果LinkedList的大小为0,则返回Null
public E peek() {
if (size==0)
return null;
return getFirst();
}
//返回第一个节点,如果LinkedList的大小为0,则抛出异常
public E element() {
return getFirst();
}
//删除并返回第一个节点,如果大小为0,则返回Null
public E poll() {
if (size==0)
return null;
return removeFirst();
}
//删除并返回第一个节点,如果大小为0,抛出异常
public E remove() {
return removeFirst();
}
//将e添加到双向链表尾部
public boolean offer(E e) {
return add(e);
}
//将e添加到双向链表头部
public boolean offerFirst(E e) {
addFirst(e);
return true;
}
//将E添加到双向链表头部
public boolean offerLast(E e) {
addLast(e);
return true;
}
//返回第一个节点,大小为0,返回Null
public E peekFirst() {
if (size==0)
return null;
return getFirst();
}
//返回最后一个节点,大小为0,返回Null
public E peekLast() {
if (size==0)
return null;
return getLast();
}
//删除并返回第一个节点,大小为0,返回Null
public E pollFirst() {
if (size==0)
return null;
return removeFirst();
}
//删除并返回最后一个节点,大小为0,返回Null
public E pollLast() {
if (size==0)
return null;
return removeLast();
}
//将e添加到第一个节点
public void push(E e) {
addFirst(e);
}
//删除并返回第一个节点
public E pop() {
return removeFirst();
}
//从linkedList头往后查找,删除第一个值为o的元素的节点
public boolean removeFirstOccurrence(Object o) {
return remove(o);
}
public boolean removeLastOccurrence(Object o) {
if (o==null) {
for (Entry<E> e = header.previous; e != header; e = e.previous) {
if (e.element==null) {
remove(e);
return true;
}
}
} else {
for (Entry<E> e = header.previous; e != header; e = e.previous) {
if (o.equals(e.element)) {
remove(e);
return true;
}
}
}
return false;
}
//返回index到尾部的全部节点对应的ListIterator对象
public ListIterator<E> listIterator(int index) {
return new ListItr(index);
}
//list迭代器
private class ListItr implements ListIterator<E> {
private Entry<E> lastReturned = header; //上一次返回的节点
private Entry<E> next;//下一个节点
private int nextIndex;//下一个节点对应的索引值
private int expectedModCount = modCount;//期望的改变计数
//构造函数,从in
ListItr(int index) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+size);
if (index < (size >> 1)) {
next = header.next;
for (nextIndex=0; nextIndex<index; nextIndex++)
next = next.next;
} else {
next = header;
for (nextIndex=size; nextIndex>index; nextIndex--)
next = next.previous;
}
}
//是否存在下一个元素
public boolean hasNext() {
return nextIndex != size;
}
//获取下一个元素
public E next() {
checkForComodification();
if (nextIndex == size)
throw new NoSuchElementException();
lastReturned = next;
next = next.next;
nextIndex++;
return lastReturned.element;
}
//是否存在上一个元素
public boolean hasPrevious() {
return nextIndex != 0;
}
//获取上一个元素
public E previous() {
if (nextIndex == 0)
throw new NoSuchElementException();
lastReturned = next = next.previous;
nextIndex--;
checkForComodification();
return lastReturned.element;
}
//获取下一位置索引
public int nextIndex() {
return nextIndex;
}
//获取上一位置索引
public int previousIndex() {
return nextIndex-1;
}
//删除双向链表的当前节点
public void remove() {
checkForComodification();
Entry<E> lastNext = lastReturned.next;
try {
LinkedList.this.remove(lastReturned);
} catch (NoSuchElementException e) {
throw new IllegalStateException();
}
if (next==lastReturned)
next = lastNext;
else
nextIndex--;
lastReturned = header;
expectedModCount++;
}
//设置当前节点为E
public void set(E e) {
if (lastReturned == header)
throw new IllegalStateException();
checkForComodification();
lastReturned.element = e;
}
//将e添加到当前节点前面
public void add(E e) {
checkForComodification();
lastReturned = header;
addBefore(e, next);
nextIndex++;
expectedModCount++;
}
// 判断 “modCount和expectedModCount是否相等”,依次来实现fail-fast机制。
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
// 双向链表的节点所对应的数据结构。
// 包含3部分:上一节点,下一节点,当前节点值。
private static class Entry<E> {
E element;
Entry<E> next;
Entry<E> previous;
Entry(E element, Entry<E> next, Entry<E> previous) {
this.element = element;
this.next = next;
this.previous = previous;
}
}
private Entry<E> addBefore(E e, Entry<E> entry) {
Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
newEntry.previous.next = newEntry;
newEntry.next.previous = newEntry;
size++;
modCount++;
return newEntry;
}
private E remove(Entry<E> e) {
if (e == header)
throw new NoSuchElementException();
E result = e.element;
e.previous.next = e.next;
e.next.previous = e.previous;
e.next = e.previous = null;
e.element = null;
size--;
modCount++;
return result;
}
// 反向迭代器
public Iterator<E> descendingIterator() {
return new DescendingIterator();
}
// 反向迭代器实现类。
private class DescendingIterator implements Iterator {
final ListItr itr = new ListItr(size());
public boolean hasNext() {
return itr.hasPrevious();
}
public E next() {
return itr.previous();
}
public void remove() {
itr.remove();
}
}
//克隆函数,返回LinkedList的克隆对象
public Object clone() {
LinkedList<E> clone = null;
try {
clone = (LinkedList<E>) super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
// Put clone into "virgin" state
clone.header = new Entry<E>(null, null, null);
clone.header.next = clone.header.previous = clone.header;
clone.size = 0;
clone.modCount = 0;
// Initialize clone with our elements
for (Entry<E> e = header.next; e != header; e = e.next)
clone.add(e.element);
return clone;
}
// 返回LinkedList的Object[]数组
public Object[] toArray() {
Object[] result = new Object[size];
int i = 0;
for (Entry<E> e = header.next; e != header; e = e.next)
result[i++] = e.element;
return result;
}
public <T> T[] toArray(T[] a) {
if (a.length < size)
a = (T[])java.lang.reflect.Array.newInstance(
a.getClass().getComponentType(), size);
int i = 0;
Object[] result = a;
for (Entry<E> e = header.next; e != header; e = e.next)
result[i++] = e.element;
if (a.length > size)
a[size] = null;
return a;
}
private static final long serialVersionUID = 876323262645176354L;
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
s.defaultWriteObject();
// Write out size
s.writeInt(size);
// Write out all elements in the proper order.
for (Entry e = header.next; e != header; e = e.next)
s.writeObject(e.element);
}
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
// Read in size
int size = s.readInt();
// Initialize header
header = new Entry<E>(null, null, null);
header.next = header.previous = header;
// Read in all elements in the proper order.
for (int i=0; i<size; i++)
addBefore((E)s.readObject(), header);
}
}
注意:对比过jdk6和jdk8的源码,对于linkedList的改变不是很多,重要的方法基本一致,属性有改动,jdk6只是在Entry header操作,而jdk8我认为为了便于操作和区分,引入node(first和last)这个node的本质和Entry是一样的,都包括前一节点,后一节点,节点值。
LinkedList不存在容量不足的问题,同时它实现了serializable接口,当写入到输出流时,先写入容量,在写入每一个节点的值;当读出输出流先读取容量,在读取每一个元素
(3)LinkedList遍历方式
1)通过迭代器(Iterator)遍历
for(Iterator iter = list.iterator(); iter.hasNext();)
iter.next();
2)通过快速随机访问这个其实我感觉就是for循环,那么就不解释增强for了
int size = list.size();
for (int i=0; i<size; i++) {
list.get(i);
}
3)通过pollFirst/pollLast遍历:
while(list.pollFirst() != null);
while(list.pollLast() != null);
4)通过removeFirst/removeLast遍历:
try {
while(list.removeFirst() != null)
;
} catch (NoSuchElementException e) {
}
try {
while(list.removeLast() != null)
;
} catch (NoSuchElementException e) {
}
通过removeFirst/removeLast效率最高,但是会删除元素数据,如果只是单独的读取不删除数据,可以使用for遍历,通过随机访问太慢慢