ArrayList源码解析
1、属性
//默认初始容量为10 private static final int DEFAULT_CAPACITY = 10; //空对象数组，当用户指定的数组长度为0时，返回该数组 private static final Object[] EMPTY_ELEMENTDATA = {}; //空对象数组，使用默认的构造方法是，返回该数组 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; //对象数组 transient Object[] elementData; //对象数组当前的容量 private int size; //分配给对象数组的最大容量 private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
2、构造方法
//无参构造方法 public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; }
public ArrayList(int initialCapacity) { if (initialCapacity > 0) { //创建指定长度的数组 this.elementData = new Object[initialCapacity]; } else if (initialCapacity == 0) { //空数组 this.elementData = EMPTY_ELEMENTDATA; } else { //如果指定的长度小于0时，抛出异常 throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); } }
//不常用 public ArrayList(Collection<? extends E> c) { elementData = c.toArray(); if ((size = elementData.length) != 0) { // 判断是不是Object类型的数组，如果不是的话，则构造一个Object类型的数组 if (elementData.getClass() != Object[].class) elementData = Arrays.copyOf(elementData, size, Object[].class); } else { // replace with empty array. this.elementData = EMPTY_ELEMENTDATA; } }
3、添加
//在数组尾部添加元素 public boolean add(E e) { //检查是否需要扩容 ensureCapacityInternal(size + 1); elementData[size++] = e; return true; }
//检查数组是否需要扩容，其中参数minCapacity表示当前数组需要存储元素的个数 private void ensureCapacityInternal(int minCapacity) { ensureExplicitCapacity(calculateCapacity(elementData, minCapacity)); }
//计算数组的最小容量 private static int calculateCapacity(Object[] elementData, int minCapacity) { //如果数组为空数组，则返回默认数组大小10和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; //原数组大小扩大1.5倍 int newCapacity = oldCapacity + (oldCapacity >> 1); if (newCapacity - minCapacity < 0) newCapacity = minCapacity; //如果新的数组的长度比MAX_ARRAY_SIZE还大的话，就越界了，则进行判断 if (newCapacity - MAX_ARRAY_SIZE > 0) newCapacity = hugeCapacity(minCapacity); //数组扩容 elementData = Arrays.copyOf(elementData, newCapacity); }
//数组长度越界判断 private static int hugeCapacity(int minCapacity) { //如果数组当前需要存储的长度小于0的话，抛出异常 if (minCapacity < 0) throw new OutOfMemoryError(); //如果数组当前需要存储的长度要大于MAX_ARRAY_SIZE,就返回int型的最大值 return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE; }
//在指定位置添加元素 public void add(int index, E element) { //判断index是否越界 rangeCheckForAdd(index); //检查是否需要扩容 ensureCapacityInternal(size + 1); //将index之后的所有元素，后移一位 System.arraycopy(elementData, index, elementData, index + 1, size - index); elementData[index] = element; size++; }
//检查是否越界 private void rangeCheckForAdd(int index) { //如果index越界，则抛出异常 if (index > size || index < 0) throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); }
注意：一开始数组是一个空数组，只有在第一次添加元素的时候，容量才会扩充为10。如果不够的话，就扩容1.5倍。
疑问：为什么要初始化为空数组呢？
因为开发中，很多时候创建了ArrayList的对象，但是没有装元素，这个时候的话，如果初始化为10的数组，就浪费空间了。
4、查找
//获取下标为index的元素 public E get(int index) { //检查下标index是否越界 rangeCheck(index); //获取下标为index的元素，并返回 return elementData(index); }
//检查下标是否越界 private void rangeCheck(int index) { //如果越界，抛出异常 if (index >= size) throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); }
//返回index下标的元素 E elementData(int index) { return (E) elementData[index]; }
5、修改
//将index下标的元素修改成element，并返回之前未修改时的元素 public E set(int index, E element) { //检查下标index是否越界 rangeCheck(index); E oldValue = elementData(index); elementData[index] = element; return oldValue; }
6、删除
//指定位置删除，并返回删除的元素 public E remove(int index) { //检查下标index是否越界 rangeCheck(index); //操作次数加一 modCount++; E oldValue = elementData(index); //将index+1及后面的元素向前移一位，覆盖被删除的值，当前值表示需要移动的元素的长度 int numMoved = size - index - 1; if (numMoved > 0) System.arraycopy(elementData, index+1, elementData, index, numMoved); elementData[--size] = null; return oldValue; }
//指定元素删除，如果有，返回true，否则返回false public boolean remove(Object o) { if (o == null) { for (int index = 0; index < size; index++) if (elementData[index] == null) { //删除下标为index的元素 fastRemove(index); return true; } } else { for (int index = 0; index < size; index++) if (o.equals(elementData[index])) { //删除下标为index的元素 fastRemove(index); return true; } } return false; }
//删除下标为index的元素 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; }
7、其他方法
//返回数组的大小 public int size() { return size; }
//判断数组是否为空 public boolean isEmpty() { return size == 0; }
//判断数组是否存在元素o public boolean contains(Object o) { return indexOf(o) >= 0; }
//检查数组是否存在元素o，如果存在，返回其第一次出现下标，否则返回-1 public int indexOf(Object o) { if (o == null) { for (int i = 0; i < size; i++) if (elementData[i]==null) return i; } else { for (int i = 0; i < size; i++) if (o.equals(elementData[i])) return i; } return -1; }
//将数组后面多余的空间删掉，长度为存储元素的个数 public void trimToSize() { //操作次数加一 modCount++; if (size < elementData.length) { elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size); } }
