浅谈java.util.ArrayList

ArrayList的成员变量

	//数组的默认容量大小
	private static final int DEFAULT_CAPACITY = 10;
	
	//当传入数组大小为0时,创建的数组
    private static final Object[] EMPTY_ELEMENTDATA = {};
    
    //默认使用无参构造器时创建的数组
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

	//真实存放数据的数组
    transient Object[] elementData; // non-private to simplify nested class access

	//数组中元素的个数
    private int size;
    
    //数组的最大容量
	private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

ArrayList构造器

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;
    }

   
    public ArrayList(Collection<? extends E> c) {
        Object[] a = c.toArray();
        if ((size = a.length) != 0) {
            if (c.getClass() == ArrayList.class) {
                elementData = a;
            } else {
                elementData = Arrays.copyOf(a, size, Object[].class);
            }
        } else {
            // replace with empty array.
            elementData = EMPTY_ELEMENTDATA;
        }
    }

结合构造器可以发现,使用无参构造器创建ArrayList,ArrayList的size大小为0,构造器参数当传入一个集合对象时,首先会将该集合转为Object数组,再将该数组复制到elementData数组当中

add()方法执行流程

add(E e)源码解析

public boolean add(E e) {
   //确保size+1后是否回超出数组容量,超出会进行扩容
   ensureCapacityInternal(size + 1);  // Increments modCount!!
   elementData[size++] = e;
   return true;
}

//判断数组是否需要扩容
private void ensureCapacityInternal(int minCapacity) {
	//先根据calculateCapacity(elementData, minCapacity)方法计算出当前数组所需的容量.
	//第二步根据ensureExplicitCapacity方法判断数组是否需要扩容
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

//计算数组当前数组所需的容量
private static int calculateCapacity(Object[] elementData, int minCapacity) {
   
   //如果当前数组为空数组,返回默认容量10和size+1的最大值
   if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
       return Math.max(DEFAULT_CAPACITY, minCapacity);
   }
   
   //否则说明数组已经有长度,将size+1返回
   return minCapacity;
}


private void ensureExplicitCapacity(int minCapacity) {
    //该成员变量指的是该对象修改的次数,与Iterator迭代器相关,如果在迭代过程对象发生修改,modCount++,会抛出异常
    modCount++;
	
	//如果数组所需容量大于数组长度则进行扩容
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

add(int index, E element)
源码解析

public void add(int index, E element) {
	//检查下标是否合理	
    rangeCheckForAdd(index); 
	
	//判断是否需要扩容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    
    //将数组从index下标开始,长度为size-index 拷贝到index+1位置中,此时index下标的元素可进行插入
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    elementData[index] = element;
    size++;
}

• add(E e)方法是将元素直接添加到数组末尾,对于一个初始化容量为0的ArrayList添加元素时,数组长度会扩容到10,每次添加元素时会判断数组是否需要扩容
• add(int index, E element)主要理解的就是System.arraycopy()添加时涉及到数据的迁移,需要向中间插入元素. System.arraycopy()详解
• 由于底层是数组,所以ArrayList是可以存放null值
• 对应还有addAll(Collection<? extends E> c)方法将集合转为数组,将该数组添加到elementData数组末尾,原理是相同的

数组扩容 grow

在add元素的时候,第一步会对数组需要扩容进行判断,那么是如何扩容的呢?
源码分析

private void grow(int minCapacity) {
    // overflow-conscious code
    //旧容量为扩容前的数组长度
    int oldCapacity = elementData.length;
    //以位运算右移的方式将原来的数组长度扩容到1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
 	
 	//判断扩容后的数组是否能存下当前数组容量,不能则将当前数组容量大小赋值给newCapacity
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;

	//判断是否大于最大容量,如果数组容量大于Integer.MAX_VALUE,则抛出OutOfMemoryError错误
    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;
}

• ** ArrayList的扩容方法,默认扩容为原来数组的1.5倍,以此来实现动态数组的结构**

remove()

源码解析

public E remove(int index) {
	//检查下标是否合理,不合理抛出异常
    rangeCheck(index);

    modCount++;
    //获取该下下标对应的元素
    E oldValue = elementData(index);
	
	//计算需要移动元素的个数,如果numMoved等于0说明index下标指向的元素是最后一个元素,直接进行删除.
    int numMoved = size - index - 1;
    if (numMoved > 0)
    	//不涉及扩容使用System.arraycopy方法提高效率
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    //将size-- 并且将最后一个元素设置为null,便于GC
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
}

• 可以看但remove元素的时候依然需要移动元素,因此ArrayList虽然随机访问较快,但是增删较慢,

实现自己的ArrayLinked

import java.util.Arrays;

public class MyArrayList<E> {
    private Object[] elementData;
    private int size;
    public MyArrayList(){
        this.elementData = new Object[10];
    }
    public MyArrayList(int capacity){
        this.elementData = new Object[capacity];
    }

    //添加元素
    public boolean add(E e){
        //判断是否需要扩容
        isGrow(size+1);
        
        elementData[size++] = e;
        return true;
    }

    public void add(int index, E element) {
        if(index < 0 || index >= size){
            throw new IndexOutOfException("IndexOutOfException");
        }
        isGrow(size++);
        //进行数据迁移
        System.arraycopy(elementData,index,element,index+1,size - index);
        elementData[index] = element;
        size++;
    }
    //进行扩容
    private void isGrow(int minCapacity) {
        if(minCapacity > elementData.length){
            int oldCapacity = elementData.length;
            int newCapacity = oldCapacity + oldCapacity >> 1;
            elementData = Arrays.copyOf(elementData,newCapacity);
        }
    }

    //获取元素
    public E get(int index) throws IndexOutOfException {
        if(index < 0 || index >= size){
            throw new IndexOutOfException("IndexOutOfException");
        }
        return (E) elementData[index];
    }

    //获取元素下标
    public int indexOf(Object object){
        if(object == null){
            for (int i = 0; i < size; i++) {
                if(elementData[i] == null){
                    return i;
                }
            }
        }else {
            for (int i = 0; i < size ; i++) {
                if(object.equals(elementData[i])){
                    return i;
                }
            }
        }
        return -1;
    }
    public int lastIndexOf(Object object){
        if(object == null){
            for (int i = size - 1; i >= 0 ; i--) {
                if(elementData[i] == null){
                    return i;
                }
            }
        }else {
            for (int i = size - 1; i >= 0 ; i--) {
                if(object.equals(elementData[i])){
                    return i;
                }
            }
        }
        return -1;

    }

    //判断是否包含元素
    public boolean contains(Object object){
        return indexOf(object) >= 0;
    }

    //删除元素
    public E remove(int index) {
        if(index < 0 || index >= size){
            return (E) new IndexOutOfException("IndexOutOfException");
        }
        E oldValue = (E) elementData[index];
        //进行数据迁移
        System.arraycopy(elementData,index + 1,elementData,index,size - index);
        elementData[size--] = null;
        return oldValue;
    }
    public boolean remove(Object o) {
        if(o == null){
            //先找到当前元素的下标
            for (int i = 0; i < size ; i++) {
                if(elementData[i] == null){
                    //进行元素删除
                    E oldValue = (E) elementData[i];
                    System.arraycopy(elementData,i+1,elementData,i,size - i);
                    elementData[size--] = null;
                    return true;
                }
            }
        }else {
            for (int i = 0; i < size; i++) {
                if(o.equals(elementData[i])){
                    E oldVale = (E) elementData[i];
                    System.arraycopy(elementData,i+1,elementData,i,size - 1);
                    elementData[size--] = null;
                    return true;
                }
            }
        }
        return false;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public int size() {
        return size;
    }

}


//自定义异常类
public class IndexOutOfException extends RuntimeException {
    public IndexOutOfException() {
        super();
    }

    public IndexOutOfException(String message) {
        super(message);
    }
}