java jdk1.8 LinkedList源码解析
2017-11-17 14:51
239 查看
java jdk1.8 LinkedList源码解析
LinkedList底层使用双向链表来实现的,双向链表也叫双链表,是链表的一种,它的每个数据结点中都有两个指针,分别指向直接后继和直接前驱。所以,从双向链表中的任意一个结点开始,都可以很方便地访问它的前驱结点和后继结点
1.LinkedList的结点类型
3.添加元素
1)在列表的开始插入特定的元素
3)在列表的末尾添加特定的元素
4)在列表的指定位置插入指定的元素,其中index从0开始
5)在list的末尾插入指定集合所有元素的结点
6)E set(int index, E element):用指定的元素element替换链列表中指定位置即index上结点的元素
1)getFirst():返回列表的第一个元素
3)get(int index):返回列表中指定位置即index上的元素
5.删除元素
1)removeFirst():删除列表中第一个元素(结点),并返回被删除结点的元素值
//删除列表中所有的元素(结点)
public void clear() {
for (Node<E> x = first; x != null; ) {//遍历list,把每个结点置为null,等待gc
Node<E> next = x.next;
x.item = null;
x.next = null;
x.prev = null;
x = next;
}
first = last = null;
size = 0;//list的大小为0
modCount++;//list的结构变化次数+1
}
LinkedList底层使用双向链表来实现的,双向链表也叫双链表,是链表的一种,它的每个数据结点中都有两个指针,分别指向直接后继和直接前驱。所以,从双向链表中的任意一个结点开始,都可以很方便地访问它的前驱结点和后继结点
1.LinkedList的结点类型
//LinkedList的结点类型 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; } }2.LinkedList的主要属性以及构造函数
public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable { //链列表包含的元素个数,其中用transient修饰,代表不需要持久化 transient int size = 0; //指向第一个结点的指针,其中用transient修饰,代表不需要持久化 transient Node<E> first; //指向最后一个结点的指针,其中用transient修饰,代表不需要持久化 transient Node<E> last; //默认的构造函数 public LinkedList() { } }
3.添加元素
1)在列表的开始插入特定的元素
//在列表的开始插入特定的元素 public void addFirst(E e) { linkFirst(e); } //将值为e的结点作为list的头结点 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为空链表 last = newNode;//尾指针指向新结点 else f.prev = newNode;//原先的头结点的前驱指向新结点 size++; //list元素个数加1 modCount++;//list的结构变化次数加1 }2)在列表的末尾添加特定的元素
//在列表的末尾添加特定的元素 public void addLast(E e) { linkLast(e); } //将值为e的结点作为list的尾结点 void linkLast(E e) { final Node<E> l = last; final Node<E> newNode = new Node<>(l, e, null); last = newNode; if (l == null)//最初list为空链表 first = newNode;//头指针指向新结点 else l.next = newNode;//原先的尾结点的后继指向新结点 size++;//list元素个数加1 modCount++;//list的结构变化次数加1 }
3)在列表的末尾添加特定的元素
//在列表的末尾添加特定的元素 public boolean add(E e) { linkLast(e); return true; }
4)在列表的指定位置插入指定的元素,其中index从0开始
//在列表的指定位置插入指定的元素,其中index从0开始 public void add(int index, E element) { checkPositionIndex(index); if (index == size)//如果在list末尾插入,如果index为0且size为0的情况下即空链表,实际上也是在list的头部进行插入 linkLast(element); else//在list原index之前插入值为element的结点,此时node(index)不是空结点 linkBefore(element, node(index)); } private void checkPositionIndex(int index) { if (!isPositionIndex(index)) throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); } //校验index private boolean isPositionIndex(int index) { return index >= 0 && index <= size; } //在一个结点succ之前插入值为e的结点 void linkBefore(E e, Node<E> succ) { // assert succ != null; final Node<E> pred = succ.prev; final Node<E> newNode = new Node<>(pred, e, succ); succ.prev = newNode; if (pred == null)//如果succ为头结点 first = newNode; else pred.next = newNode; size++;//list元素个数加1 modCount++;//list的结构变化次数加1 } //返回列表中指定位置(index)上的结点,其中index从0开始 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; } }
5)在list的末尾插入指定集合所有元素的结点
//在list的末尾插入指定集合所有元素的结点 public boolean addAll(Collection<? extends E> c) { return addAll(size, c); } //从指定的位置index开始,插入集合中所有元素的值到list public boolean addAll(int index, Collection<? extends E> c) { checkPositionIndex(index);//校验index Object[] a = c.toArray();//把集合转化成数组 int numNew = a.length; if (numNew == 0)//集合为空,直接返回false return false; Node<E> pred, succ;//其中pred是插入集合后的前驱,succ是插入集合后的后继 if (index == size) {//要在末尾插入 succ = null; pred = last; } else { 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)//在列表的头部插入即index为0 first = newNode; else pred.next = newNode; pred = newNode; } if (succ == null) {//在列表末尾插入,即index=size last = pred; } else { pred.next = succ; succ.prev = pred; } size += numNew;//list的大小增加集合的元素个数 modCount++;//list结构变化次数增加集合的元素个数 return true; }
6)E set(int index, E element):用指定的元素element替换链列表中指定位置即index上结点的元素
//用指定的元素element替换链列表中指定位置即index上结点的元素 public E set(int index, E element) { checkElementIndex(index);//校验index是否合法 Node<E> x = node(index);//获取index位置上的结点 E oldVal = x.item; x.item = element; return oldVal; }4.查找元素
1)getFirst():返回列表的第一个元素
//返回列表的第一个元素 public E getFirst() { final Node<E> f = first; if (f == null) throw new NoSuchElementException(); return f.item; }2)getLast():返回列表的最后一个元素
//返回列表的最后一个元素 public E getLast() { final Node<E> l = last; if (l == null) throw new NoSuchElementException(); return l.item; }
3)get(int index):返回列表中指定位置即index上的元素
//返回列表中指定位置即index上的元素 public E get(int index) { checkElementIndex(index);//校验index合法性 return node(index).item; }4)indexOf(Object o):返回特定元素即o在列表中第一次出现的位置,如果不存在返回-1
//返回特定元素即o在列表中第一次出现的位置,如果不存在返回-1 public int indexOf(Object o) { int index = 0; if (o == null) {//查找的元素o为null for (Node<E> x = first; x != null; x = x.next) { if (x.item == null) return index; index++; } } else {//查找的元素o不为null for (Node<E> x = first; x != null; x = x.next) { if (o.equals(x.item)) return index; index++; } } return -1; }5)lastIndexOf(Object o):返回特定元素即o在列表中最后一次出现的位置,如果不存在返回-1
//返回特定元素即o在列表中最后一次出现的位置,如果不存在返回-1 public int lastIndexOf(Object o) { int index = size; if (o == null) {//查找的元素o为null for (Node<E> x = last; x != null; x = x.prev) { index--; if (x.item == null) return index; } } else {//查找的元素o不为null for (Node<E> x = last; x != null; x = x.prev) { index--; if (o.equals(x.item)) return index; } } return -1; }6)contains(Object o):判断列表是否包含指定的元素o
//判断列表是否包含指定的元素o public boolean contains(Object o) { return indexOf(o) != -1; }
5.删除元素
1)removeFirst():删除列表中第一个元素(结点),并返回被删除结点的元素值
//删除列表中第一个元素(结点),并返回被删除结点的元素值 public E removeFirst() { final Node<E> f = first; if (f == null) throw new NoSuchElementException(); return unlinkFirst(f); } private E unlinkFirst(Node<E> f) { // assert f == first && f != null; final E element = f.item; final Node<E> next = f.next; f.item = null; f.next = null; // help GC first = next; if (next == null) last = null; else next.prev = null; size--;//list的大小-1 modCount++;//list的结构变化次数+1 return element; }2)removeLast():删除列表中最后一个元素(结点),并返回被删除结点的元素值
//删除列表中最后一个元素(结点),并返回被删除结点的元素值 public E removeLast() { final Node<E> l = last; if (l == null) throw new NoSuchElementException(); return unlinkLast(l); } private E unlinkLast(Node<E> l) { // assert l == last && l != null; final E element = l.item; final Node<E> prev = l.prev; l.item = null; l.prev = null; // help GC last = prev; if (prev == null) first = null; else prev.next = null; size--;//list的大小-1 modCount++;//list的结构变化次数+1 return element; }3)remove(int index):删除列表中指定位置即index上的元素(结点)
//删除列表中指定位置即index上的元素(结点) public E remove(int index) { checkElementIndex(index);//校验index的合法性 return unlink(node(index)); } //删除结点x 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; if (prev == null) { first = next; } else { prev.next = next; x.prev = null; } if (next == null) { last = prev; } else { next.prev = prev; x.next = null; } x.item = null; size--;//list元素个数-1 modCount++;//list的结构变化次数加1 return element; }4)remove(Object o):删除第一次出现在列表中的特定元素o
//删除第一次出现在列表中的特定元素o public boolean remove(Object o) { if (o == null) {//如果要删除的元素为null for (Node<E> x = first; x != null; x = x.next) { if (x.item == null) { unlink(x); return true; } } } else {//如果要删除的元素不为null for (Node<E> x = first; x != null; x = x.next) { if (o.equals(x.item)) { unlink(x); return true; } } } return false; }5)clear():删除列表中所有的元素(结点)
//删除列表中所有的元素(结点)
public void clear() {
for (Node<E> x = first; x != null; ) {//遍历list,把每个结点置为null,等待gc
Node<E> next = x.next;
x.item = null;
x.next = null;
x.prev = null;
x = next;
}
first = last = null;
size = 0;//list的大小为0
modCount++;//list的结构变化次数+1
}
相关文章推荐
- 【Java深入研究】2、JDK 1.8 LinkedList源码解析
- Java jdk1.8 安装
- Java JDK1.8新特性
- Java开发环境配置--JDK 1.8
- 关于java访问修饰符的几个测试(jdk1.8)
- Java集合: ConcurrentHashMap源码分析 JDK1.8
- JAVA环境变量配置详细步骤和JDK1.8详细安装步骤
- java8 JDK1.8 API 中文 翻译版 java帮助文档
- java JDK1.8安装与环境配置
- Java集合框架成员之HashTable类的源码分析(基于JDK1.8版本)
- ubuntu 配置 java jdk1.8 环境,增加多版本 jdk 和切换方法
- CentOS7中的安装与配置Java Jdk 1.8
- JDK1.8源码学习之ConcurrentHashMap.java
- 解压jdk1.8安装包(exe)后,java.version -version报错 Error occurred during initialization of VM,java/lang/NoClassDefFoundError: java/lang/Object
- Install Oracle Java JDK 1.8 On CentOS 6.5
- Java集合学习之HashMap 一(JDK1.8)
- ubuntu14.04,安装JDK1.8(JAVA程序需要的开发、运行环境)
- Java面试绕不开的问题: Java中HashMap底层实现原理(JDK1.8)源码分析
- java容器源码分析--HashSet(JDK1.8)
- Java中HashMap底层实现原理(JDK1.8)源码分析