1. ArrayList的实现原理
在ArrayList类内部维护了一个数组(固定长度)来存储数据
// 默认初始化容量
private static final int DEFAULT_CAPACITY = 10;
// 空数组,用来实例化不带容量大小的构造函数
private static final Object[] EMPTY_ELEMENTDATA = {};
// 保存ArrayList中数据的数组
private transient Object[] elementData;
// ArrayList中实际数据的数量
private int size = 0;
在初始化集合时对数组elementData进行初始化, 默认的初始化容量为10;
1.1 初始化数组elementData
在ArrayList集合中有两个构造函数对elementData数组进行初始化
含有参数的:
public JDKArrayList(int initialCapacity) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
this.elementData = new Object[initialCapacity];
}
根据传入的初始化容量创建数组
无参的:
public JDKArrayList() {
super();
this.elementData = EMPTY_ELEMENTDATA;
}
将EMPTY_ELEMENTDATA空数组赋给elementData数组
1.2 在向集合中添加数据,如果数组elementData中存储数据已满时, 对数组进行扩容
public boolean add(E e) {
//在添加数据之前先判断elementData数组是否已满; 如果已满, 则进行扩充
// size + 1 和 minCapacity: 代表elementData数组此时必须存在的最小容量;
// size: 代表数组中已存入数据的数量, size初始化值为0;
ensureCapacityInternal(size + 1);
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
// 如果是个空数组,说明在使用无参构造函数初始化后并未存储数据
if (elementData == EMPTY_ELEMENTDATA) {
// 取minCapacity和初始化容量10的较大者(在数组最小容量小于默认容量时一律设置为默认容量10)
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
// 如果数组的最小容量可以存储添加的数据
ensureExplicitCapacity(minCapacity);
}
// 确保数组容量大于ArrayList中元素个数
private void ensureExplicitCapacity(int minCapacity) {
// 将“修改统计数”+1
modCount++;
// 如果实际数据容量大于数组容量,就给数组扩容
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
// 增大数组空间
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1); // 在原来容量的基础上加上
// oldCapacity/2
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity; // 最少保证容量和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);
}
2、手写ArrayList集合
2.1首先创建集合接口
package com.lic.arrayList;
public interface MyList<E>{
public boolean add(E object);
public boolean add(int index, E object);
public Object remove(int index);
public boolean remove(E object);
public int size();
public Object get(int index);
}
2.2 创建实现类
package com.lic.arrayList;
import java.util.Arrays;
public class MyArrayList<E> implements MyList<E>{
// 实际保存ArrayList数据的数组(长度固定)
private Object[] elementData;
// 数组默认初始化容量
private static final int DEFAULT_CAPACITY = 10;
// elementData数组中已存储元素的个数
private int size = 0;
// 创建有参构造函数(指定集合容量)
public MyArrayList(int miniCatacity) {
if (miniCatacity < 0) {
throw new IllegalArgumentException("集合容量不能小于0");
} else if (miniCatacity == 0) {
elementData = new Object[DEFAULT_CAPACITY];
}
elementData = new Object[miniCatacity];
}
// 创建无参构造函数(不指定集合容量,使用默认集合容量)
public MyArrayList() {
this(DEFAULT_CAPACITY);
}
// 实现集合的add()方法
public boolean add(E e) {
// 1.先判断elementData数组是否已满,如果已满,则扩充该数组
ensureCapacityInternal(size + 1);
// 2.将元素加入数组中
elementData[size++] = e;
return true;
}
// 实现集合的add()方法:向指定位置插入数据
public boolean add(int index, E newObject) {
// 先判断elementData数组是否已满,如果已满,则扩充该数组
ensureCapacityInternal(size + 1);
//在指定位置后(包括指定位置)有多少个数据需要向后移动
int numAdded = size - index;
System.arraycopy(elementData, index, elementData, index + 1, numAdded);
elementData[index] = newObject;
size++;
return true;
}
//数组扩充
private void ensureCapacityInternal(int minCapacity) {
if (size == elementData.length) {
// 计算出新的扩容容量(1.5倍扩容)
int newCapacity = size + size >> 1;
// 如果新的扩容容量小于最小扩容容量,则将最小扩容容量设置为新扩容容量(防止size为1时扩容出现扩容失败问题,所以将最小扩容容量设置为size+1);
if (newCapacity < minCapacity) {
newCapacity = minCapacity;
}
elementData = Arrays.copyOf(elementData, newCapacity);
}
}
public E get(int index) {
// 检查数组下标是否越界
rangeCheck(index);
return elementData(index);
}
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
}
public void rangeCheck(int index) {
if (index >= size || index < 0) {
throw new IndexOutOfBoundsException("数组下标越界!");
}
}
public E remove(int index) {
// 检查数组下标是否越界
rangeCheck(index);
E oldObject = elementData(index);
// 计算出即将删除的目标元素之后有多少个元素需要向前移动(如果使用elementData.length代替size,可以实现删除效果,但是效率略低;)
int numMoved = size - 1 - index;
if (numMoved > 0)
System.arraycopy(elementData, index + 1, elementData, index, numMoved);
// 此句有两个功能:1.将elementData数组中最后一个有效元素(非null元素)置为空; 2.将size减1
elementData[--size] = null;
return oldObject;
}
public boolean remove(E e) {
if (e != null) {
for (int i = 0; i < size; i++) {
if (e.equals(elementData[i])) {
remove(i);
return true;
}
}
}
return false;
}
//返回数组有效长度
public int size() {
return size;
}
}
3、Vector底层实现原理
Vector是线程安全的,但是性能比ArrayList要低。
ArrayList,Vector主要区别为以下几点:
(1) Vector是线程安全的,源码中有很多的synchronized可以看出,而ArrayList不是。导致Vector效率无法和ArrayList相比;
(2) ArrayList和Vector都采用线性连续存储空间,当存储空间不足的时候,ArrayList默认增加为原来的50%,Vector默认增加为原来的一倍;
(3) Vector可以设置capacityIncrement,而ArrayList不可以,从字面理解就是capacity容量,Increment增加,容量增长的参数。
private void grow(int minCapacity)
{
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + ((capacityIncrement <= 0) ? oldCapacity : capacityIncrement);
if(newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if(newCapacity - MAX_ARRAY_SIZE> 0)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
}