ArrayList用法详解与源码分析

说明

1.创建ArrayList对象

//创建默认容量的数组列表（默认为10）
ArrayList<E> a = new ArrayList<E>();

//创建容量为initialCapacity的数组列表
ArrayList<E> a = new ArrayList<E>(int initialCapacity);

//用一个集合来初始化数值列表
ArrayList<E> a = new ArrayList<E>(Collection<? extends E> c);

Mark：

2.ArrayList方法

向ArrayList添加元素

/***********a是上面创建的ArrayList对象***************/

//添加一个元素
a.add(E e);

//在特定的位置添加元素,index后面的元素全部向后移一位
a.add(int index, E e);

//在ArrayList 后面 添加集合
a.addAll(Collection<? extends E> c);

//从特定的位置添加集合
a.addAll(int index, Collection<? extends E> c);

获取ArrayList的元素

//获取特定索引的元素
a.get(int index);

Mark：

修改（更新）ArrayList的元素

//用e替换换index位置的元素
a.set(int index, E e);

Mark：

删除ArrayList的元素

//删除索引为index的元素，后面的元素全都向前移一位
a.remove(int index);

/*删除在列表中和obj相等的第一个元素（首次出现），
* 就做动作，保持列表原来的状态
* 比如：a [1, 3, 7, 5, 7],执行a.remove((Integer)7)后
* 结果为：[1, 3, 5, 7]
*/
a.remove(Object obj);

//删除与集合c中元素相等的元素
a.removeAll(Collection<?> c);

//保留与集合c中元素相等的元素，然后把其他元素删除（与removeAll相反）
a.retainAll(Collection<?> c);

//删除ArrayList的所有元素,没有removeAll();方法
a.clear();

ArrayList的其他一些比较常用的方法

//获取ArrayList的元素个数
a.size();

//判断ArrayList是否包含某个元素
a.contains(Object o)

//判断ArrayList是否是空列表([])，是就返回true
a.isEmpty();

//获取ArrayList的子列表,(字串包含索引为fromIndex的元素，不包含toIndex元素）
a.subList(int fromIndex, int toIndex);

//返回ArrayList的基本数组形式
a.toArray();

/**ArrayList克隆，调用方法后，会返回a的一份复制。它与普通的复制(=)不同
*赋值后，两个引用指向同一个对象，会相互影响
*从ArrayList源码可知，是开辟新的空间来新建一个对象，再把数据复制到新建的对象。
*所以，clone后会形成两个不同的对象，因此不会相互影响。
*/
a.clone();

Mark:

ArrayList源码分析

首先，看看ArrayList定义的属性

private static final int DEFAULT_CAPACITY = 10;
private static final Object[] EMPTY_ELEMENTDATA = {};
transient Object[] elementData;
private int size;

实现可变长数组的主要方法：


ensureCapacityInternal解析

/**
* 此函数大概就叫内部容量确定函数，主要是在每次添加元素这些增大size的
* 动作里调用，用来判断需不需要增加capacity大小实现动态分配
*/
private void ensureCapacityInternal(int minCapacity) {
/**
*这个判断只要是针对使用new ArrayList<E>()构造对象设定，以免频繁的扩容。
*如果if判断为真，那么就是使用new ArrayList<E>()构造对象的.
*此刻就要选一个最大的容量作为期待的最小容量，避免频繁扩容
*详细解析看下面的例子！！
*/
if (elementData == EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}

//调用最终确认方法，需不需要扩容由此方法决定
ensureExplicitCapacity(minCapacity);
}

if (elementData == EMPTY_ELEMENTDATA)

作用解析

首先，我们新建一个类（我的为MyList），把ArrayList的源码复制过来方便为所欲为～～，然后把一些报错除去。最后我们修改下代码：

// 把ensureCapacityInternal的if语句注释掉，
/*if (elementData == EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}*/
在**grow**方法里添加一个输出语句
System.out.println("-----invoke grow()------------");

写我们的测试类：

public class Test {
public static void main(String[] args) {

MyList<Integer> i = new MyList<Integer>();
MyList<Integer> i2 = new MyList<Integer>(10);

System.out.println("------使用new MyList<Integer>()------ ");
i.add(1);
i.add(1);
i.add(1);
i.add(1);

System.out.println("------使用new MyList<Integer>(10)------ ");
i2.add(1);
i2.add(1);
i2.add(1);
i2.add(1);
}

}

输出：


可以看出，如果不是使用if判断，使用new ArrayList()方法每次添加元素都会调用grow，而每次调用grow都会生成一个新的数组。所以为了效率内存考虑要添加if判断。

ensureExplicitCapacity方法

/**
*此代码功能很简单，只是进行一个简单的判断，看是否需要扩容
*如果需要的容量比实际的容量大就进行扩容
*/
private void ensureExplicitCapacity(int minCapacity) {
modCount++;

if (minCapacity - elementData.length > 0)
grow(minCapacity);
}

grow（核心方法）

/**
*扩容的具体动作
*/
private void grow(int minCapacity) {

int oldCapacity = elementData.length;

//定义扩容后的容量大小为原来容量的3/2
int newCapacity = oldCapacity + (oldCapacity >> 1);
//如果扩容后的容量还是比期待的容量小，那么使用minCapacity为扩容后的容量
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);

/*这里实现了动态数组的特性。
*跟踪copyOf源码可以发现，实现方法:新建一个大小为newCapacity数组，
*然后把elementData之前的元素复制到新的数组，
*最后把新数组返回f赋值给elementData以实现动态数组
*/
elementData = Arrays.copyOf(elementData, newCapacity);
}

总结：

常用方法分析

add方法

public boolean add(E e) {
//此方法上面已介绍
ensureCapacityInternal(size + 1);
//操作elementData，把e添加到数组里
elementData[size++] = e;
return true;
}

set方法

public E set(int index, E element) {
//检查是否越界，该函数代码很简单，就是简单判断index与size大小。
rangeCheck(index);

//以下代码跟add对比下就知道他们的区别
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}

​