常见的List接口的实现类

常见的List接口的实现类

• ArrayList：数组实现，查询快，增删慢，轻量级；(线程不安全)
• LinkedList：双向链表实现，增删快，查询慢 (线程不安全)
• Vector：数组实现，重量级 (线程安全、使用少)

ArrayList实现类

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable

内部实现

transient Object[] elementData;  用于存储数据，体现ArrayList采用的是数组的方式提供实现

构造器

//new ArrayList(1000);
public ArrayList(int initialCapacity) {  //参数是初始化容积
	if (initialCapacity > 0) { 如果容积初始值大于0则创建对应的对象
    	this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) { 如果容积值为0则创建一个空数组
        this.elementData = EMPTY_ELEMENTDATA;
    } else { 如果小于0则抛出一个运行时异常
    	throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
    }
}
//new ArrayList();
 public ArrayList() {  没有初始化参数值，则自动创建一个0个长的空数组
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

add方法的实现

//向存储数据的elementData添加新元素
public boolean add(E e) {
	ensureCapacityInternal(size + 1);  //确保内部容量,处理数组elementData的长度，确保可以存放数据，如果当前数组长度不足，则需要增加数组长度。参数的含义是满足条件的最小容积
	elementData[size++] = e;
	return true;   //如果添加过程中不出异常，则返回一定是true
}

ensureCapacityInternal方法

private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
    
private void ensureExplicitCapacity(int minCapacity) {
	modCount++;  //修改次数加1
	if (minCapacity - elementData.length > 0)  如果所需要的最小容积大于实际存储数据的数组长度，则需要进行扩容处理
		grow(minCapacity);
}
    
private void grow(int minCapacity) {
	int oldCapacity = elementData.length;  //获取实际数组的长度
	//符号>>表示二进制向右移位计算，>>1表示除以2,>>2表示除以4(2的平方).如果<<表示乘以2的多少次方
	int newCapacity = oldCapacity + (oldCapacity >> 1);  //新的容积值=旧有容器*1.5
	if (newCapacity - minCapacity < 0)  新容器如果小于所需要的最小容积，则新容积为最小容积值
		newCapacity = minCapacity;
            
	//int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8
	if (newCapacity - MAX_ARRAY_SIZE > 0)   如果新容积值大于所允许的最大容积值
	    newCapacity = hugeCapacity(minCapacity);  获取满足最小容积需求的合法的容积值
	//从elementData拷贝所有的数组元素，Arrays是工具类，提供了常见的针对数组的操作方法
	elementData = Arrays.copyOf(elementData, newCapacity);
}
    
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0)   如果最小容积值小于0则抛出错误，表示OOM内存溢出
        throw new OutOfMemoryError();
        //例如获取的最小容积值为Integer.MAX_VALUE-7
    return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

add方法用于向集合中添加元素，如果ArrayList中真正存放数据的数组长度不足，则新建一个数组，新数组的长度为原始长度1.5倍，并拷贝原始数组中的数据到新数组中，最后再追加新元素

LinkedList

类定义

public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>,
Cloneable, java.io.Serializable
//Deque是队列接口，提供一个双端队列的访问方法实现

底层实现为双向链表

private static class Node<E> { //节点定义
	E item; //具体存储的数据
	Node<E> next; //向后的指针
	Node<E> prev; //向前的指针
}

LinkedList类中的数据存储

transient Node<E> first; //头指针,指向链表的第一个元素
transient Node<E> last； //尾指针,指向链表的最后一个元素

对应的构造器

public LinkedList() { //没有初始化容积
}

add方法中

• 创建Node对象，其中包含需要添加的元素值
• Node对象的next为null
• prev指向last
• last对象的next为新建对象Node
• last指向新建的Node对象

Vector

类定义
属于老版本提供的，从1.0，而ArrayList比较新，从1.2。属于线程安全的类，大部分方法上都有synchronized，一般用于要求线程安全的属性定义

public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable,
java.io.Serializable

数据存储

protected Object[] elementData; 采用也是数组的方式存储数据

构造器方法

public Vector() {
	this(10); //表示调用当前类的其它构造器，初始化容积为10，增长的步长值为0 
}
public Vector(int initialCapacity) {
	this(initialCapacity, 0);
}
public Vector(int initialCapacity, int capacityIncrement) { //参数1是初始化容积，参数2是容
积增长的步长值
	super();
	if (initialCapacity < 0)
		throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
	this.elementData = new Object[initialCapacity]；//按照初始化容积值构建对应的数组
	this.capacityIncrement = capacityIncrement; 
}

add新增元素的方法实现

public synchronized boolean add(E e) {//线程安全的方法
	modCount++; //修改次数+1
 	ensureCapacityHelper(elementCount + 1); //处理容积
 	elementData[elementCount++] = e; //在数组中存储元素
 	return true; 
 }
private void ensureCapacityHelper(int minCapacity) {
	// overflow-conscious code
 	if (minCapacity - elementData.length > 0) //需要储存的数据超出数组可以存放的数据格
式，则需要进行增长
 		grow(minCapacity);
}
private void grow(int minCapacity) {
	int oldCapacity = elementData.length; //当前数组的长度，也就是可以存放的元素个数
	int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement :
oldCapacity); //新长度为原始长度的2倍或者原始长度+步长值
 	if (newCapacity - minCapacity < 0) //如果新长度不满足最小长度要求，则新长度为最小要
求的长度
 		newCapacity = minCapacity;
 	if (newCapacity - MAX_ARRAY_SIZE > 0) //如果新长度大于最大数组长度进行长度处理
 		newCapacity = hugeCapacity(minCapacity);
 	elementData = Arrays.copyOf(elementData, newCapacity); //将原始数组中的数据拷贝到新
数组中,并替换原始数组
}
private static int hugeCapacity(int minCapacity) { //和ArrayList处理一致
 	if (minCapacity < 0) //OOM 内存溢出
 		throw new OutOfMemoryError();
 	return (minCapacity > MAX_ARRAY_SIZE) ?
 	Integer.MAX_VALUE :
 	MAX_ARRAY_SIZE;
}

• 方法同步
• 增长为2倍
• 无参数创建时是10个长的数组

删除元素的方法remove(Object)

public boolean remove(Object o) {
	return removeElement(o);
}
public synchronized boolean removeElement(Object obj) {
	modCount++;
	int i = indexOf(obj); //查找元素的索引值
	if (i >= 0) {
		removeElementAt(i); //按照索引删除指定元素
		return true;
	}
	return false;
}
public synchronized void removeElementAt(int index) {
	modCount++;
	//针对index索引值进行合法性验证
	if (index >= elementCount) {
		throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
	} else if (index < 0) {
		throw new ArrayIndexOutOfBoundsException(index);
	}
	
	int j = elementCount - index - 1; //获取需要移动的元素个数
	if (j > 0) { //通过拷贝的方式将数据的后续移动元素向前移动一位
		System.arraycopy(elementData, index + 1, elementData, index, j);
	}
	elementCount--; //元素个数-1
	elementData[elementCount] = null; //将数组末尾的元素值赋null
}

List总结

	ArrayList	LinkedList	Vector
实现方式	数组，按照索引下标访问速度快O(1),但是当删除、添加元素时会导致元素的移动，速度慢O(n)	双向链表，按照索引下标访问速度慢O(n)，但是删除添加元素速度快O(1)	数组，按照索引下标访问速度快O(1),但是当删除添加元素时会导致元素的移动，速度慢O(n)
是否同步	不同步,线程不安全，但是并发高,访问效率高	不同步,线程不安全，但是并发高,访问效率高	同步,所以线程安全，但是并发低,访问效率低
如何选择	经常需要快速访问，较少在中间增加删除元素时使用;如果多线程访问，则需要自行编程解决线程安全问题	经常需要在内部增删元素，但是很少需要通过索引快速访问时使用;如果多线程访问，则需要自行编程解决线程安全问题	一般不使用，如果在多线程访问时可以考虑使用