Java集合系列(3)--LinkedList
来源:互联网 发布:moe软件官网 编辑:程序博客网 时间:2024/05/16 15:22
前面我们已经学习到了ArrayList,接着我们来学习LinkedList。LinkedList也像ArrayList一样实现了基本的List接口,和学习ArrayList一样,下面我们先对LinkedList有个整体的认识,然后学习它的源码,最后通过实例来更熟练的使用它。
一、LinkedList的基本概述
LinkedList 是一个继承于AbstractSequentialList的双向链表。实现了List、Deque、Cloneable、Java.io.serializable接口,它也可以被当作堆栈、队列或双端队列进行操作,。
LinkedList 实现 List 接口,能对它进行队列操作。
LinkedList 实现 Deque 接口,即能将LinkedList当作双端队列使用。
LinkedList 实现了Cloneable接口,即覆盖了函数clone(),能克隆。
LinkedList 实现java.io.Serializable接口,这意味着LinkedList支持序列化,能通过序列化去传输。
由上面可以得到:LinkedList 是非线程安全的,集合中的元素允许为空,保存的元素为有序的,实现了List接口,则允许集合中的元素是可以重复的。
面试易考点:
二、LinkedList的数据结构
两个属性
LinkedList中定义了两个属性
private transient Entry<E> header = new Entry<E>(null, null, null);private transient int size = 0;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; }}
size:LinkedList对象中存储的元素个数。
header:LinkedList是基于链表实现的,那么这个header肯定就是链表的头结点了,Entry就是节点对象了。
Entry类中只定义了存储的元素、前一个元素、后一个元素,这就是双向链表的节点的定义,每个节点只知道自己的前一个节点和后一个节点。
三、LinkedList的API
1>LinkedList的构造方法
public LinkedList() { header.next = header.previous = header;}public LinkedList(Collection<? extends E> c) { this(); addAll(c);}
第一个构造方法不接受参数,只是将header节点的前一节点和后一节点都设置为自身(注意,这是一个双向循环链表,如果不是循环链表,空链表的情况应该是header节点的前一节点和后一节点均为null),这样整个链表其实就只有header一个节点,用于表示一个空的链表。第二个构造方法接收一个Collection参数c,调用第一个构造方法构造一个空的链表,之后通过addAll将c中的元素全部添加到链表中。接下来看addAll类的具体内容。
public boolean addAll(Collection<? extends E> c) { return addAll(size, c);}// index参数指定collection中插入的第一个元素的位置public boolean addAll(int index, Collection<? extends E> c) { // 插入位置超过了链表的长度或小于0,会报IndexOutOfBoundsException异常 if (index < 0 || index > size) throw new IndexOutOfBoundsException("Index: "+index+ ", Size: "+size); Object[] a = c.toArray(); int numNew = a.length; // 若需要插入的节点个数为0则返回false,表示没有插入元素 if(numNew==0) return false; modCount++; // 保存index处的节点。插入位置如果是size,则在头结点前面插入,否则获取index处的节 点 Entry<E> successor = (index==size ? header : entry(index)); // 获取前一个节点,插入时需要修改这个节点的next引用 Entry<E> predecessor = successor.previous; // 按顺序将a数组中的第一个元素插入到index处,将之后的元素插在这个元素后面 for (int i=0; i<numNew; i++) { // 结合Entry的构造方法,这条语句是插入操作,相当于C语言中链表中插入节点并修改指针 Entry<E> e = new Entry<E>((E)a[i], successor, predecessor); // 插入节点后将前一节点的next指向当前节点,相当于修改前一节点的next指针 predecessor.next = e; // 相当于C语言中成功插入元素后将指针向后移动一个位置以实现循环的功能 predecessor = e; } // 插入元素前index处的元素链接到插入的Collection的最后一个节点 successor.previous = predecessor; // 修改size size += numNew; return true;}
构造方法中的调用了addAll(Collection
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 { // 可以通过header节点向前遍历,说明这是一个循环双向链表,header的previous指向链表的最后一个节 //点,这也验证了构造方法中对于header节点的前后节点均指向自己的解释 for (int i = size; i > index; i--) e = e.previous; } return e; }
从上面的分析中以及双向循环链表的知识,相对比较容易理解LinkedList构造方法所涉及的内容。下面开始分析LinkedList的其他方法。
2>元素存储
LinkedList添加了add(E e)、addBefore(E e,Entry entry)、 add(int index,E e)、addFirst(E e)、 addLast(E e)等添加元素的方法。
public boolean add(E e) { addBefore(e, header); return true;}
add(E e)方法只是调用了addBefore(E e,Entry entry)方法,并且返回true
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;}
addBefore(E e,Entryentry)方法是个私有方法,所以无法在外部程序中调用(当然,这是一般情况,你可以通过反射上面的还是能调用到的)。
addBefore(E e,Entryentry)先通过Entry的构造方法创建e的节点newEntry(包含了将其下一个节点设置为entry,上一个节点设置为entry.previous的操作,相当于修改newEntry的“指针”),之后修改插入位置后newEntry的前一节点的next引用和后一节点的previous引用,使链表节点间的引用关系保持正确。之后修改和size大小和记录modCount,然后返回新插入的节点。
则有,addBefore(E e,Entry entry)实现在entry之前插入由e构造的新节点。而add(E e)实现在header节点之前插入由e构造的新节点。
add(int index, E element)
public void add(int index, E element) { addBefore(element, (index==size ? header : entry(index))); }
也是调用了addBefore(E e,Entry entry)方法,只是entry节点由index的值决定。
addFirst(E e)
public void addFirst(E e) { addBefore(e, header.next); }
public void addLast(E e) {
addBefore(e, header);
}
结合addBefore(E e,Entry entry)方法,很容易理解addFirst(E e)只需实现在header元素的下一个元素之前插入。addLast(E e)只需在实现在header节点前(因为是循环链表,所以header的前一个节点就是链表的最后一个节点)插入节点。
3>元素读取
set(int index,E element)
public E set(int index, E element) {2 Entry<E> e = entry(index);3 E oldVal = e.element;4 e.element = element;5 return oldVal;6 }
由上面的代码可以得到,先获取指定索引的节点,之后保留原来的元素,然后用element进行替换,之后返回原来的元素。
get(int index)
public E get(int index) { return entry(index).element; }
get(int index)方法用于获得指定索引位置的节点的元素。它通过entry(int index)方法获取节点。entry(int index)方法遍历链表并获取节点,entry的方法也是根据索引值,一步步开始遍历的。
getFirst()
public E getFirst() { if (size==0) throw new NoSuchElementException(); return header.next.element; }
element()
public E element() { return getFirst(); }
element()方法调用了getFirst()返回链表的第一个节点的元素。从代码上看,两者并没有什么不同,像是包装了一下名字,其实这只是为了在不同的上下文“语境”中能通过更贴切的方法名调用罢了。
getLast()
public E getLast() { if (size==0) throw new NoSuchElementException(); return header.previous.element; }
getLast()方法和getFirst()方法类似,只是获取的是header节点的前一个节点的元素。因为是循环链表,所以header节点的前一节点就是链表的最后一个节点。
4>元素删除
remove()
1 public E remove() {2 return removeFirst();3 }
remove(int index)
1 public E remove(int index) {2 return remove(entry(index));3 }
remove(Object o)
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;}
removeFirst()
1 public E removeFirst() {2 return remove(header.next);3 }
removeLast()
1 public E removeLast() {2 return remove(header.previous);3 }
从上面代码中,可以看到几个remove方法最终都是调用了私有方法:remove(Entry e),其中的简单逻辑稍有区别。下面分析remove(Entry e)方法。
private E remove(Entry<E> e) { if (e == header) throw new NoSuchElementException(); // 保留将被移除的节点e的内容 E result = e.element; // 将前一节点的next引用赋值为e的下一节点 e.previous.next = e.next; // 将e的下一节点的previous赋值为e的上一节点 e.next.previous = e.previous; // 上面两条语句的执行已经导致了无法在链表中访问到e节点,而下面解除了e节点对前后 节点的引用 e.next = e.previous = null; // 将被移除的节点的内容设为null e.element = null; // 修改size大小 size--; modCount++; // 返回移除节点e的内容 return result;}
有一个clear()类,清空双向链表
public void clear() { Entry<E> e = header.next; // 从表头开始,逐个向后遍历;对遍历到的节点执行一下操作: // 设置前一个节点为null // 设置当前节点的内容为null // 设置后一个节点为“新的当前节点” while (e != header) { Entry<E> next = e.next; e.next = e.previous = null; e.element = null; e = next; } header.next = header.previous = header; // 设置大小为0 size = 0; modCount++; }
5>元素查找
indexOf(Object o)
从前向后查找,返回“值为对象(o)的节点对应的索引”,不存在就返回-1
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; }
lastIndexOf(Object o)
从后向前查找,返回值“为对象(o)的节点对应的索引”, 不存在就返回-1
查找的是last index,即最后一次出现的位置,所以采用由后向前的遍历方式。因为采用了由后向前的遍历,所以index被赋值为size,并且循环体内执行时都进行减操作。分两种情况判断是否存在,分别是null和不为空。
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;}
6>元素包含
判断LinkedList是否包含元素(o)
public boolean contains(Object o) { return indexOf(o) != -1; }
7>返回静态数组toArray()
// 返回LinkedList的Object[]数组 public Object[] toArray() { // 新建Object[]数组 Object[] result = new Object[size]; int i = 0; // 将链表中所有节点的数据都添加到Object[]数组中 for (Entry<E> e = header.next; e != header; e = e.next) result[i++] = e.element; return result; } // 返回LinkedList的模板数组。所谓模板数组,即可以将T设为任意的数据类型 public <T> T[] toArray(T[] a) { // 若数组a的大小 < LinkedList的元素个数(意味着数组a不能容纳LinkedList中全部元素) // 则新建一个T[]数组,T[]的大小为LinkedList大小,并将该T[]赋值给a。 if (a.length < size) a = (T[])java.lang.reflect.Array.newInstance( a.getClass().getComponentType(), size); // 将链表中所有节点的数据都添加到数组a中 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; }
8>其它API
// 是否存在下一个元素 public boolean hasNext() { // 通过元素索引是否等于“双向链表大小”来判断是否达到最后。 return nextIndex != size; } // 获取下一个元素 public E next() { checkForComodification(); if (nextIndex == size) throw new NoSuchElementException(); lastReturned = next; // next指向链表的下一个元素 next = next.next; nextIndex++; return lastReturned.element; } // 是否存在上一个元素 public boolean hasPrevious() { // 通过元素索引是否等于0,来判断是否达到开头。 return nextIndex != 0; } // 获取上一个元素 public E previous() { if (nextIndex == 0) throw new NoSuchElementException(); // next指向链表的上一个元素 lastReturned = next = next.previous; nextIndex--; checkForComodification(); return lastReturned.element; } // 双向链表的节点所对应的数据结构。 // 包含3部分:上一节点,下一节点,当前节点值。 private static class Entry<E> { // 当前节点所包含的值 E element; // 下一个节点 Entry<E> next; // 上一个节点 Entry<E> previous; /** * 链表节点的构造函数。 * 参数说明: * element —— 节点所包含的数据 * next —— 下一个节点 * previous —— 上一个节点 */ Entry(E element, Entry<E> next, Entry<E> previous) { this.element = element; this.next = next; this.previous = previous; } }
四、LinkedList遍历方式
1>第一种,通过迭代器遍历。即通过Iterator去遍历。
for(Iterator iter = list.iterator(); iter.hasNext();) iter.next();
2>通过快速随机访问遍历LinkedList
int size = list.size();for (int i=0; i<size; i++) { list.get(i); }
3>通过增强for循环来遍历LinkedList
for (Integer integ:list) { System.out.println(integ); }
当然还有其它的遍历方式,但通过比较得出,无论如何,千万不要通过随机访问去遍历LinkedList!即for循环的方式。
补充:
此实现不是同步的。如果多个线程同时访问一个链接列表,而其中至少一个线程从结构上修改了该列表,则它必须保持外部同步。(结构修改指添加或删除一个或多个元素的任何操作;仅设置元素的值不是结构修改。)这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象,则应该使用 Collections.synchronizedList 方法来“包装”该列表。最好在创建时完成这一操作,以防止对列表进行意外的不同步访问,如下所示:
List list = Collections.synchronizedList(new LinkedList(...));
此类的 iterator 和 listIterator 方法返回的迭代器是快速失败 的:在迭代器创建之后,如果从结构上对列表进行修改,除非通过迭代器自身的 remove 或 add 方法,其他任何时间任何方式的修改,迭代器都将抛出 ConcurrentModificationException。因此,面对并发的修改,迭代器很快就会完全失败,而不冒将来不确定的时间任意发生不确定行为的风险。 注意,迭代器的快速失败行为不能得到保证,一般来说,存在不同步的并发修改时,不可能作出任何硬性保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此,编写依赖于此异常的程序的方式是错误的,正确做法是:迭代器的快速失败行为应该仅用于检测程序错误。
文章只是作为自己的学习笔记,借鉴了网上的许多案例,如果觉得可以的话,希望多交流,在此谢过…
- Java集合系列(3)--LinkedList
- 【java集合系列】--- LinkedList
- JAVA学习---集合系列---LinkedList
- java集合框架系列---LinkedList
- Java集合系列02--LinkedList
- Java集合(LinkedList)
- java集合(3):LinkedList源码分析
- JAVA笔记:集合系列—LinkedList
- Java集合系列之LinkedList源码分析
- 深入Java集合系列之二:LinkedList
- Java集合系列之二:LinkedList
- Java集合系列之LinkedList源码分析
- 深入java集合系列:java8 LinkedList详解
- JAVA集合(三)-LinkedList
- Java集合-LinkedList(一)
- Java集合(三)-LinkedList
- java集合系列——List集合之LinkedList介绍(三)
- 集合系列LinkedList
- LeetCode:Implement Trie (Prefix Tree) 深度优先遍历,hash指针,数据设计
- Web访问原理-从输入URL到页面加载完成的过程中都发生了什么事情?
- 01、SSM框架整合搭建
- 我们一起走那精英之路——半年总结
- 307. Range Sum Query - Mutable
- Java集合系列(3)--LinkedList
- aes加密算法的理解
- eclipse安装MAT
- Ruby on Rails学习笔记(9)--ruby语法中的简写
- 战胜拖延症重要的几点
- (14)稀疏矩阵的压缩-三元组(相乘)
- Go 之旅一: 包、变量和函数
- 创建型-单例模式
- PHP中的常见魔术方法功能作用及用法实例