Java ArrayList源码分析（有助于理解数据结构）

arraylist源码分析

1.数组介绍

数组是数据结构中很基本的结构，很多编程语言都内置数组，类似于数据结构中的线性表

在java中当创建数组时会在内存中划分出一块连续的内存，然后当有数据进入的时候会将数据按顺序的存储在这块连续的内存中。当需要读取数组中的数据时，需要提供数组中的索引，然后数组根据索引将内

存中的数据取出来，返回给读取程序。在Java中并不是所有的数据都能存储到数组中，只有相同类型的数据才可以一起存储到数组中。

  

 因为数组在存储数据时是按顺序存储的，存储数据的内存也是连续的，所以他的特点就是：寻址读取数据比较容易，插入和删除比较困难。

带参构造方法

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; //给一个成员变量赋值
    }
　　private static final Object[] DEFAULTCAPACITY EMPTY ELEMENTDATA={}; //空参构造方法创建的数组就是一个空的

下面这个用的不多，能看懂即可

public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray(); //把Collection这个集合也变成了一个数组，传给了当前数组elementData
　　　　　//大于0，就拷贝数组
        if ((size = elementData.length) != 0) { //判断当前elementData数组的长度，如果不等于0
            if (elementData.getClass() != Object[].class) //判断类型是不是Object数组类型，如果不是这个类型
                elementData = Arrays.copyOf(elementData, size, Object[].class);  //拷贝一个数组，然后长度，然后把Object[].class数组传进去，然后生成一个elementData数组
　　　　　//不是大于0，就拷贝一个空的
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA; //设置为空数组
        }
    }

 添加元素

public boolean add(E e) {
　　　　　检测是否需要扩容
       下¹ensureCapacityInternal(minCapacity：size + 1);  // size是当前存的数据个数
　　　　　数组赋值

        elementData[size++] = e;
        return true;
    }

 扩容的入口方法，计算容量

private void 上¹ensureCapacityInternal(int minCapacity){ //minCapacity最小值，传的时候就是+1后的
下下³ensureExplicitCapacity(下²calculateCapacity(elementData,minCapacity)); //计算容量，传入一个数组elementData，再传一个最小容量minCapacity

计算最小容量

private static int 上²calculateCapacity(Object[] elementData, int minCapacity){
//如果elementData是空的
if(elementData==DEFAUL TCAPACITY EMPTY EL EMENTDAT)|
//返回一个默认或者minCapacity，最后是返回其中最大的
return Math. max(DEFAULT_CAPACIT minCapacity); 
//不是空，就返回size+1的值 
return minCapacity;
}

private void 上上³ensureExplicitCapacity(int minCapacityp{
//只要发生修改就+1
modCount++; 
//是否满足扩容的条件   最小容量（当前数组存值得容量？） - object数组的长度
if(minCapacity-elementData. length〉0）//elementData.lenth=10 （默认容量为10）
下¹grow(minCapacity);

 数组扩容方法

private void 上¹grow(int minCapacity){
　　　//计算当前数组容量，也就是老的容量
　 　int oldCapacity=elementData. length;
　　　//新的数组容量 = 老容量 + 老容量/2  （老容量的1.5倍）
 　　int newCapacity=oldCapacity+(oldCapacity >>1);  >>1 除二

　　　　 // oldcapacity=10
　　　　// oldcapacity >>1
　　　　// 0000 1010 >> 1
　　　　// 0000 0101 = 5

　　　　//判断新的数组容量-之前最小容量

 　　if(newCapacity-minCapacity<0)
　　　　　　newCapacity=minCapacity;
　　 if (newCapacity - MAX_ARRAY_SIZE>0)  //MAX_ARRAY_SIZE：值特别大，如果新的数组比它还大，就越界了，或者直接返回最大长度
　　　　　　newCapacity = hugeCapacity(minCapacity);
　　　elementData=Arrays. copyof(elementData, newCapacity);

private static int 上上上³calculateCapacity(Object[] elementData, int minCapacity){
//如果elementData是空的
if(elementData==DEFAUL TCAPACITY EMPTY EL EMENTDAT)|
//返回一个默认或者minCapacity，最后是返回其中最大的
return Math. max(DEFAULT_CAPACIT minCapacity); 
//不是空，就返回size+1的值 
return minCapacity;
}

    public void add(int index, E element) {
　　　　　判断下标是否越界
        rangeCheckForAdd(index);
　　　　　检测是否需要扩容
        ensureCapacityInternal(size + 1); 
　　　　　　把index之后的所有元素向后移动一位

        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
　　　　　将index位置覆盖上新值

        elementData[index] = element;
        size++;
    }

private void rangeCheckForAdd(int index){
if(index>size || index<0)
throw new IndexOutofBoundsException(outofBoundsMsg(index));

System.arraycopy(elementData, index, elementData, index + 1,size - index); 举例

int
[] elementData = new int[10];
 for(int i=0;i<5;i++){ //数组的下标 0,1,2,3,4
elementData[i]=i+1;  //数组的值 1,2,3,4,5
System. out. println("=="+Arrays. toString(elementData)); 
int size=5; 
int index=1; //插入数组下标位置
 System. arraycopy(elementData, index, elementData, destPos: index+1, length: size-index);   原数组，插入指定的位置，又指定的数组，指定的位置为当前位置+1，到5-1=4的位置 >>从插入位置往后算
System. out. println("--"+Arrays. toString(elementData));

打印结果

 ==  [1，2，3，4，5，0，0，0，0，0]
 一  [1，2，2，3，4，5，0，0，0，0]  2：是要插入的数值

删除方法

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

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