1.ArrayList 与 LinkedList 的继承与实现
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
- ArrayList 继承了AbstractList,实现了List,RandomAccess, Cloneable, java.io.Serializable,RandomAccess是个标识类,实现了该类,遍历的时候使用for循环快,如果没有实现,则使用迭代器
- LinkedList 继承了AbstractSequentialList,实现了List<E>, Deque<E>, Cloneable, java.io.Serializable,Deque是双队列
2.ArrayList 与 LinkedList 的底层实现
ArrayList 底层是数组
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
transient Object[] elementData;
private int size;
LinkedList 底层是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;
}
}
由此可以看出:
- ArrayList 底层使用的数组,查询更加方便快捷
- LinkedList 底层使用的链表,插入删除更加方便快捷
3.ArrayList 与 LinkedList 的构造函数
ArrayList 可以设置默认长度(查看源码可知,默认长度为0)而LinkedList 则不需要
4.ArrayList 与 LinkedList 的新增
ArrayList 新增源码:
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
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++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
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 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++;
}
以上可以看出:
- ArrayList 新增耗时主要再扩容方面,扩容后的大小为 原大小的1.5倍
- LinkedList 新增则直接再末尾添加,添加前后标识即可
当然异同还有很多,先到这