List集合
List集合的三个子类:
-
ArrayList
底层使用数组结构,线程不安全
-
LinkedList
底层使用链表结构,线程不安全
-
Vector
底层使用数组结构,线程不安全
ArrayList解析
ArrayList是我们平时使用非常多的一个集合。
属性
private static final long serialVersionUID = 8683452581122892189L;
private static final int DEFAULT_CAPACITY = 10;
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//用于存储的结构
transient Object[] elementData;
private int size;
从属性看出,ArrayList底层是使用Object数组来存储的。而ArrayList是通过其”扩容“机制来进行扩容,从而实现动态增长的。
构造方法
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
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[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}
如果初始化时指定了容量,则返回对应容量的数组,否则返回DEFAULTCAPACITY_EMPTY_ELEMENTDATA(默认空元素数组)
Add方法
add方法可以说是ArrayList中非常重要的方法。
public boolean add(E e) {
//先确认list的容量,尝试容量+1,看看有无必要,再添加元素
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
//ensureCapacityInternal确定需要的最小容量
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
//如果需要的最小容量比数组的长度要长,则调用grow()扩容。
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
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);
//扩容完成后调用copyof将原数组复制到新数组中
elementData = Arrays.copyOf(elementData, newCapacity);
}
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
@SuppressWarnings("unchecked")
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
- 先检查数组容量是否足够
- 不够时,扩容到原来的1.5倍。
- 如果容量还是小于最小需求容量,则扩大到最小需求容量。
public void add(int index, E element) {
//检查越界
rangeCheckForAdd(index);
//确保数组大小
ensureCapacityInternal(size + 1);
//直接使用最底层的arraycopy方法进行数组复制
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
arraycopy()是java底层,用C/C++实现的系统函数。
get方法
public E get(int index) {
//先检查索引是否符合大小
rangeCheck(index);
//返回对应位置的元素
return elementData(index);
}
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
E elementData(int index) {
return (E) elementData[index];
}
set方法
public E set(int index, E element) {
//检查索引范围
rangeCheck(index);
//将旧的值返回
E oldValue = elementData(index);
//将新的值替换
elementData[index] = element;
return oldValue;
}
remove方法
//根据下标删除
public E remove(int index) {
//检查下标范围
rangeCheck(index);
modCount++;
E oldValue = elementData(index);
//计算需要移动的元素数量
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//将最后一个元素值为空,等待GC回收
// clear to let GC do its work
elementData[--size] = null;
return oldValue;
}
//通过元素查找删除
public boolean remove(Object o) {
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
//fastRemove操作和remove(int)同理
fastRemove(index);
return true;
}
} else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
细节说明
- ArrayList是基于动态数组实现的,在增删的时候,需要数组的复制操作。
- ArrayList的默认初始化容量是10,每次扩容的时候先增加原来容量的1.5倍,如果不够的话,扩容到指定大小。
- 删除元素时不会减少容量,如果希望容量适应则调用trimToSize()
- ArrayList是不是线程安全的,且它能存放null值
Vector与ArrayList的区别
Vector底层也是数组结构,与ArrayList最大的区别就是,线程安全
public synchronized E set(int index, E element){}
public synchronized E get(int index){}
public synchronized boolean add(E e){}
public synchronized E remove(int index){}
从方法中可以看出,Vector和ArrayList的方法实现是几乎一致的,最大的区别就是,每一个方法都使用了synchronized关键字来实现同步。
在不要求同步的情况下,一般使用ArrayList。
如果需要实现同步时,可以使用
List list = Collection.synchronizedList(new ArrayList(...));
还有另外一个区别,ArrayList的扩容机制是在原来基础上扩容到1.5倍,而Vector直接扩容到原来的2倍。
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);
}
LinkedList解析
LinkedList底层是双向链表,从结构上,LinkedList还实现了Deque接口,因此,操作LinkedList可以像操作队列和栈一样。
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable{
transient int size = 0;
transient Node<E> first;
transient Node<E> last;
}
LinkedList中只存放了头结点,尾结点和长度三个属性。
构造方法
/**
* Constructs an empty list.
*/
public LinkedList() {
}
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
特意把无参构造器的注释写了过来,无参构造器居然是空的。
add方法
//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 = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
public void add(int index, E element) {
//确认下标范围
checkPositionIndex(index);
//如果是末尾,直接尾插法。如果非末尾,则插到指定元素之前。
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
remove方法
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
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;
}
}
//从链表中删掉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--;
modCount++;
return element;
}
get方法
public E get(int index){
checkElementIndex(index);
return node(index).item;
}
set方法
public E set(int index,E element){
checkElementIndex(index);
Node<E> x = node(index);
E oldVal = x.item;
x.item = element;
return oldVal;
}
总结
ArrayList:
- 底层实现是数组,且线程不安全
- 默认初始化容量是10,每次扩容的时候增加到原来的1.5倍
- 在增删的时候,需要数组的复制(System.arrayCopy)
LinkedList:
- 底层实现是双向链表,且线程不安全
- 集成了Quene接口,有队列操作方法
Vector:
- 底层实现是数组,线程安全
- 极少情况下使用,被ArrayList替代。
- Vector所有方法都是同步的,有性能损失
- Vector初始长度是10,超过长度时,扩容到原来的2倍
总结
总的来说,查询多用ArrayList,增删多用LinkedList。
ArrayList增删慢不是绝对的(在数据量大的情况下):
- 如果增加元素一直是使用add方法(增加到末尾),那么ArrayList更快
- 一直删除末尾元素也是ArrayList要快
- 如果删除的是最中间的位置,还是ArrayList快
但是,一般情况下,增删操作多的集合选用LinkedList,以上情况只针对特殊情况。