java集合之List底层实现原理
List：
1.List接口是继承自Collection，所以Collection集合中有的方法，List集合也继承过来
2.List中存储的元素可以重复的存储相关元素
3.List集合下面有ArrayList、LinkedList、Vector
ArrayList：
-
ArrayList底层是由动态数组实现的。动态数组就是长度不固定，随着数据的增多而变长。在底层定义了一个名为elementData的数组，添加数据和删除数据都基于这个数组之上进行操作，在实例化一个ArrayList时，如果不指定它的长度，则默认为10 （在下面的第二点和第三点可以得到）（#这里的长度是指elementData这个底层数组的长度而不是ArrayList.size得到的长度）：
不指定长度实例和指定长度实例：
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() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; } -
ArrayList在每次添加元素的时候都会先进行容量检测以及扩容操作（grow），这个grow方法将数组的容量扩大1.5倍的容量 ：
private void grow(int minCapacity) { // overflow-conscious code int oldCapacity = elementData.length; int newCapacity = oldCapacity + (oldCapacity >> 1); //如果扩容1.5倍还不够，则直接将需要拓展的最小容量赋给扩容的容量 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); } -
ArrayList的add方法中，会先调用ensureCapacityInternal方法来检查是否超出数组容量，如果超出的话则调用grow方法：
public boolean add(E e) { ensureCapacityInternal(size + 1); // Increments modCount!! elementData[size++] = e; return true; }private static int calculateCapacity(Object[] elementData, int minCapacity) { //判断这个ArrayList是不是指定长度实例 if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { return Math.max(DEFAULT_CAPACITY, minCapacity); } return minCapacity; } private void ensureCapacityInternal(int minCapacity) { ensureExplicitCapacity(calculateCapacity(elementData, minCapacity)); } private void ensureExplicitCapacity(int minCapacity) { modCount++; // overflow-conscious code if (minCapacity - elementData.length > 0) grow(minCapacity); } -
ArrayList中指定下标添加元素的add方法，先调用rangeCheckForAdd判断给出索引是否在可用范围
public void add(int index, E element) { rangeCheckForAdd(index); ensureCapacityInternal(size + 1); // Increments modCount!! System.arraycopy(elementData, index, elementData, index + 1, size - index); elementData[index] = element; size++; }其中System.arraycopy（）方法的函数原型：
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 其中：src表示源数组，srcPos表示源数组要复制的起始位置，desc表示目标数组，length表示要复制的长度。（缺点）简而言之ArrayList在每次存储，所有的元素都会向后移动位置 。同理，如果删除一个元素，后面的元素都会向前移动一个位置。因此，ArrayList在存储和删除的时候效率比较低。
所以这里再来说说ArrayList的remove方法
1.根据下标移出元素：
remove(int index)：同样先调用rangeCheck判断给出下标是否合理，然后用int numMoved = size - index - 1计算出需要复制的长度，如果numMoved==0则表示移出的是最后一个元素，不需要进行复制操作
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; }2.根据指定元素移出：
public boolean remove(Object o)：先判断移出的元素是否为null，若不为null则进行下一步判断，用for循环遍历直到找到指定元素的下标，调用fastRemove方法
public boolean remove(Object o) { if (o == null) { for (int index = 0; index < size; index++) if (elementData[index] == null) { fastRemove(index); return true; } } else { for (int index = 0; index < size; index++) if (o.equals(elementData[index])) { fastRemove(index); return true; } } return false; }private void fastRemove(int index) { modCount++; 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 }
知道了ArrayList的缺点，那他的优点是什么呢，接下来来说说它的优点：
查找的时候，根据元素的下标可以迅速访问数组中的任意元素，查询效率非常高
ArrayList的get方法（查找）：直接根据下标返回数组元素
public E get(int index) {
rangeCheck(index);
return elementData(index);
}
补充一些ArrayList的其他方法：
1.public E set(int index, E element)： //将指定下标的元素替换成指定元素
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
2.public void clear()： //清除所有元素
public void clear() {
modCount++;
// clear to let GC do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
3.public boolean addAll(Collection<? extends E> c)： //添加一个集合
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}
此外还有removeAll，isEmpty等等，这里就不一一介绍
LinkedList：
LinkedList底层是由双向链表的数据结构实现的
双向链表是由三个部分组成：prev、data、next
prev：由用来存储上一个节点的地址
data：是用来存储要存储的数据
next：是用来存储下一个节点的地址
为了比较LinkedList和ArrayList，这里就只说说它的增删和查询方法
当我们有新元素插入时，只需要修改所要插入位置的前一个元素的next值和后一个元素的prev值即可。比如我们在数据3与数据7之间插入一个数据4的元素，那么只需要修改数据3的next值和数据7的prev值。
删除也是同理，比如要删除数据8的元素，只需要修改数据7的next值和数据9的prev值即可，然后数据8没有元素指向它，它就成了垃圾对象，最后被回收。因此在增加和删除的时候只需要更改前后元素的next和prev值，效率非常高。但是在查询的时候需要从第一个元素开始查找，直到找到我们需要的数据为止，因此查询的效率比较低。
查询：
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;
}
}
861
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
