1、ArrayList是基于数组,LinkedList是基于链表
2、基于数组的ArrayList对于根据索引值查找比较高效;基于链表的LinkedList对于增加、删除操作比较高效
3、剖析CRUD:
ArrayList:
Create(增加):
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
if (elementData == EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(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);
}
思路:1、首先size+1、然后判断size+1和elementData长度比较,若增加之后的size大于elementData长度,则进行动态增加数组elementData 长度
2、动态增加长度策略:对原来elementData长度进行oldCapacity + (oldCapacity >> 1)相当于elementData长度的1.5倍,然后用这个1.5倍与增加之后元素的个数比较,哪个大用哪个
3、然后进行数组elementData 的复制,长度采用上一步比较的数字。
(注意1、elementData 长度 并不一定等于数组内元素的个数。2、modCount 为本数组修改的次数(在add、remove和改变list的方法中)
))
Retrieve(查询):
public E get(int index) {
rangeCheck(index);
return elementData(index);
}
因为是基于数组,所以查询根据索引值可直接获取。
Update(修改):
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
先查再改,简单明了。
Delete(删除):
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);
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
思路:1、根据索引值,进行数组拷贝,把index之后的元素向前挪动1。
2、size-1索引的地方设为null,垃圾回收。
LinkedList:
Create(增加):
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++;
}
链表增加默认在尾部增加:将原先尾部的next指向新增的元素节点。
Retrieve(查询):
public E get(int index) {
checkElementIndex(index); //检查索引值是否大于元素数目
return node(index).item;
}
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;
}
}
思路:1、若索引值小于链表长度的1/2,则在前半部查询,反之,则在后半部查询
Update(修改):
先查再改,耗时主要在查。
Delete(删除):
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
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;
}
链表删除操作:1、将需要删除的prev节点next指向需要删除的next节点。
2、将需要删除的next节点prev指向需要删除的prev节点。