-
ArrayList
-
ArrayList 底层右数组实现,初始化ArrayList后默认创建一个为空的数组,在第一添加元素时候 会扩容为长度为10的数组,后续扩容将以原来的数据的1.5倍进行扩容
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
//默认容量
private static final int DEFAULT_CAPACITY = 10;
//初始化Object 类型空数组
private static final Object[] EMPTY_ELEMENTDATA = {};
//Object数组
transient Object[] elementData;
//数组长度
private int size;
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//无参构造方法
public ArrayList() {
//默认初始化为空的Object数组
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//添加元素方法
public boolean add(E e) {
//确保容量够大
ensureCapacityInternal(size + 1); // Increments modCount!!
//赋值并 将 size加1
elementData[size++] = e;
return true;
}
//确保容量
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
//计算容量
private static int calculateCapacity(Object[] elementData, int minCapacity) {
//判断容量元素是否是空
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
//比较默认容量和最小容量并返回最大值
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
//判断需不需要扩容
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
//当数组长度不够长时扩容
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) {
// 获取当前数组长度
int oldCapacity = elementData.length;
//计算获得新数组长度 (X+(x/2))即原来的1.5倍长度
int newCapacity = oldCapacity + (oldCapacity >> 1);
//如果计算的到长度小于最小容量则按照最小容量扩容
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
//将扩容后的新数组copy上数据,指针指向elementData
elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?Integer.MAX_VALUE :MAX_ARRAY_SIZE;
}
}
-
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;
public LinkedList() {
}
private static class Node<E> {
E item;//当前元素
Node<E> next;//前一个元素
Node<E> prev;//后一个元素
//构造Node对象
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
//获取列表长度
public int size() {
return size;
}
//添加元素
public boolean add(E e) {
linkLast(e);
return true;
}
void linkLast(E e) {
//队尾节点赋值l
final Node<E> l = last;
//调用构造方法返回Node对象
final Node<E> newNode = new Node<>(l, e, null);
//将添加元素设置为最后一个节点
last = newNode;
//判断是否是第一个节点添加
if (l == null)
//将队列头设置给当前添加元素
first = newNode;
else
//队尾的下一个指针指向添加的节点
l.next = newNode;
//增加队列长度
size++;
modCount++;
}
}
总结:
1、数据结构不同
ArrayList是Array(动态数组)的数据结构,LinkedList是Link(链表)的数据结构。
2、效率不同
当随机访问List(get和set操作)时,ArrayList比LinkedList的效率更高,因为LinkedList是线性的数据存储方式,所以需要移动指针从前往后依次查找。
当对数据进行增加和删除的操作(add和remove操作)时,LinkedList比ArrayList的效率更高,因为ArrayList是数组,所以在其中进行增删操作时,会对操作点之后所有数据的下标索引造成影响,需要进行数据的移动。
3、自由性不同
ArrayList自由性较低,因为它需要手动的设置固定大小的容量,但是它的使用比较方便,只需要创建,然后添加数据,通过调用下标进行使用;而LinkedList自由性较高,能够动态的随数据量的变化而变化,但是它不便于使用。
4、主要控件开销不同
ArrayList主要控件开销在于需要在lList列表预留一定空间;而LinkList主要控件开销在于需要存储结点信息以及结点指针信息。