List
结构图
三者比较
ArrayList | Vector | LinkedList | |
---|---|---|---|
数据结构 | 数组 | 数组 | 链表 |
元素 | 可重复 | 可重复 | 可重复 |
扩容 | 1.5倍 | 默认1倍扩容 | 不需要 |
优点 | 查询快 | 查询快 | 查询慢 |
缺点 | 增删慢 | 增删慢 | 增删快 |
安全性 | 不安全 | 安全,但效率低 | 不安全 |
ArrayList源码
继承关系
public class ArrayList<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
-
RandomAccess接口支持随机访问
-
Serializable支持序列化
底层数据结构
//Obj类型的数组来存储数据
//transient修饰的变量不能被序列化
transient Object[] elementData;
主要属性
//默认容量
private static final int DEFAULT_CAPACITY = 10;
//空数组
private static final Object[] EMPTY_ELEMENTDATA = {};
//我们将其与 EMPTY_ELEMENTDATA 区分开来,以了解添加第一个元素时要膨胀多少
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//元素存储
transient Object[] elementData;
//元素数量
private int size;
//数组被修改的次数
protected transient int modCount = 0;
构造方法
//无参构造
public ArrayList() {
//将数组初始化为空数组
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//指定容量的构造方法
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) { //参数大于0直接初始化数组
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
//EMPTY_ELEMENTDATA一个空数组对象
this.elementData = EMPTY_ELEMENTDATA;
} else {
//小于0抛出异常
throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
}
}
//按照集合的迭代器返回的顺序构造一个包含指定集合元素的列表
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// c.toArray might (incorrectly) not return Object[]
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}
增加
//添加元素
public boolean add(E e) {
//确保容量
ensureCapacityInternal(size + 1); // Increments modCount!!
//尾插
elementData[size++] = e;
return true;
}
//在指定位置添加元素
public void add(int index, E element) {
//位置合法性判断
rangeCheckForAdd(index);
//确保容量
ensureCapacityInternal(size + 1); // Increments modCount!!
//将当前位置及之后的元素向后移动
System.arraycopy(elementData, index, elementData, index + 1,size - index);
//插入
elementData[index] = element;
size++;
}
扩容
private void grow(int minCapacity) {
//获取数组容量
int oldCapacity = elementData.length;
//1.5倍扩容
int newCapacity = oldCapacity + (oldCapacity >> 1);
//容量合法性判断
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
//数组元素放入新数组
elementData = Arrays.copyOf(elementData, newCapacity);
}
删除
public E remove(int index) {
//位置合法性判断
rangeCheck(index);
//数组操作数+1
modCount++;
//获取元素
E oldValue = elementData(index);
//数组更新
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//clear to let GC do its work
elementData[--size] = null;
return oldValue;
}
LinkedList源码
继承关系
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
-
Serializable支持序列化
-
实现Dqueue接口可以作为队列使用
主要属性
//元素个数
transient int size = 0;
//头节点
transient Node<E> first;
//尾节点
transient Node<E> last;
//此列表在结构上被修改的次数。结构修改是那些改变列表大小的修改,或者以其他方式扰乱它,以致正在进行的迭代可能会产生不正确的结果。如果实现不希望提供快速失败的迭代器,则可以忽略此字段.
protected transient int modCount = 0;
底层数据结构
//用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;
}
}
构造方法
//无参构造函数
public LinkedList() { }
//按照集合的迭代器返回的顺序构造一个包含指定集合元素的列表
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
增加
//头插法
private void linkFirst(E e) {
//获取头节点
final Node<E> f = first;
//new新节点
final Node<E> newNode = new Node<>(null, e, f);
//更新头节点
first = newNode;
//更新前驱后继
if (f == null)
last = newNode;
else
//将原来的头节点挂在新的头节点上
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++;
}
删除
//头删
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--;
modCount++;
return element;
}
//尾删
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--;
modCount++;
return element;
}
Vector源码
继承关系
public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
-
RandomAccess接口支持随机访问
-
Serializable支持序列化
主要属性
//存储数组
protected Object[] elementData;
//元素数量
protected int elementCount;
//增加容量
protected int capacityIncrement;
底层数据结构
//Obj类型的数组来存储数据
protected Object[] elementData;
构造方法
//指定容量和扩容时的增量
public Vector(int initialCapacity, int capacityIncrement) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
this.capacityIncrement = capacityIncrement;
}
//指定容量
public Vector(int initialCapacity) {
this(initialCapacity, 0);
}
//无参构造
public Vector() {
this(10);
}
//按照集合的迭代器返回的顺序构造一个包含指定集合元素的向量
public Vector(Collection<? extends E> c) {
elementData = c.toArray();
elementCount = elementData.length;
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
}
增加
//通过synchronized保证安全性
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
扩容
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
capacityIncrement : oldCapacity);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
}
删除
//通过synchronized保证安全性
public synchronized boolean removeElement(Object obj) {
modCount++;
int i = indexOf(obj);
if (i >= 0) {
removeElementAt(i);
return true;
}
return false;
}