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

arraylist源码分析

1.数组介绍

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

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

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

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

带参构造方法

public ArrayList(intinitialCapacity) {if (initialCapacity > 0) {

//创建指定长度的数组this.elementData = newObject[initialCapacity];

}else if (initialCapacity == 0) {

//空数组this.elementData =EMPTY_ELEMENTDATA;

}else{throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);} //如果既不大于零，也不小于零，就会报错抛出异常

}

空参构造方法

publicArrayList() {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 booleanadd(E e) {

//检测是否需要扩容

下¹ensureCapacityInternal(minCapacity：size+ 1); //size是当前存的数据个数

//数组赋值

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

}

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

private void 上¹ensureCapacityInternal(intminCapacity){ //minCapacity最小值，传的时候就是+1后的

下下³ensureExplicitCapacity(下²calculateCapacity(elementData,minCapacity)); //计算容量，传入一个数组elementData，再传一个最小容量minCapacity

计算最小容量

private static int 上²calculateCapacity(Object[] elementData, intminCapacity){//如果elementData是空的

if(elementData==DEFAUL TCAPACITY EMPTY EL EMENTDAT)|

//返回一个默认或者minCapacity，最后是返回其中最大的

returnMath. max(DEFAULT_CAPACIT minCapacity);//不是空，就返回size+1的值

returnminCapacity;

}

private void 上上³ensureExplicitCapacity(intminCapacityp{

//只要发生修改就+1

modCount++;//是否满足扩容的条件 最小容量(当前数组存值得容量？) - object数组的长度

if(minCapacity-elementData. length〉0)//elementData.lenth=10 (默认容量为10)

下¹grow(minCapacity);

数组扩容方法

private void 上¹grow(intminCapacity){//计算当前数组容量，也就是老的容量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);

public void add(intindex, 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(intindex){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(intindex) {

检测当前下标是否越界

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

returnoldValue;

}

private void 上rangeCheck(int index){

if(index >=size)

throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

上上 System.arraycopy(elementData, index+1, elementData, index, numMoved); 举例int[] elementData = new int[10];

for(int i=0;i<10;i++){ //数组的下标 0,1,2,3,4,5,6,7,8,9

elementData[i]=i+1; //数组的值 1,2,3,4,5,6,7,8,9,10}

int size = elementData.lengh; //数组里有几个数，长度就是几 elementData.lengh = 10

int index = 2;

int numMoved = size - index - 1;

System. out. println("==" + Arrays. toString(elementData));

System. arraycopy(elementData, srcPos:index+1, elementData, index, numMoved); 原数组，指定的位置为要删除的下标往后一个位置，又指定的数组，删除位置的下标，10-2-1=7 >>从指定删除下标位置往后数，全部向前移动一位

System. out. println("--" + Arrays. toString(elementData));

打印结果== [1，2，3，4，5，6，7,8,9,10] 3：要删除的数字

一 [1，2，4,5,6,7,8,9,10,10]

指定元素删除

public boolean remove(Object o) {

if (o == null) {

for (int index = 0; index < size; index++)

if (elementData[index] == null) {

下fastRemove(index);

return true;} //从0开始遍历，大小为数组长度，找到后直接删除

} else {

for (int index = 0; index < size; index++)

if (o.equals(elementData[index])) {

fastRemove(index);

return true;

}

}

如果没有匹配元素，返回false

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; // clear to let GC do its work

}