文章目录
前言：
如果作为java开发工程师，大家都使用过List的主要实现类ArrayList，那么你真的懂他吗？
-
1.ArrayList是单列的、存储有序的、可重复的、线程不安全的，但是你知道为什么吗？
-
2.是不是感觉ArrayList与数组非常相似? 那么为什么ArrayList不会下标越界呢？那ArrayList底层做了什么呢？
-
3.如题：从java7到java8进行了哪些迭代？为什么要这样做？
- java8的ArrayList是什么样子的？
- java7的ArrayList是什么样子的？
-
4.如何高效的使用ArrayList?
环境介绍
因为本身详细介绍与对比了java7和java8的ArrayList的源码，在此声明本文的环境：
- JDK7(以jdk-7u7-windows-x64为例)：后续文章简称为java8
- JDK8(以jdk-8u131-windows-x64为例)：后续文章中简称java7
问题一：ArrayList是单列的、存储有序的、可重复的、线程不安全的，但是你知道为什么吗？
1.为什么是单列的？
下面一段代码是小编从java中ArrayList的源码中截取的（这里java7和java8不存在差异），elementData这个成员变量的作用是对ArrayList的添加的元素进行存储，可以看出这是一个Object类型的数组，因为数组是线程存储的，所以ArrayList也是线性存储的。
/**
* 存储ArrayList元素的数组缓冲区。ArrayList的容量是这个数组缓冲区的长度。任何带有
* elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA的空ArrayList将在添加第一
* 个元素时扩展为DEFAULT_CAPACITY。
*/
transient Object[] elementData; // non-private to simplify nested class access
2.为什么有序的？
从上面可以看出，ArrayList底层是Object类型的数组进行存储，数组是有序的，所以其存储也是有序的,那么接下来，咱们进行验证一下：
@Test
public void test()
{
ArrayList list=new ArrayList();
list.add(1);
list.add(2);
list.add(3);
System.out.println("list的输出结果:"+list);
}
根据结论可以看出，ArrayList的确是顺序存储的。
3.为什么是可重复的？
闲话少说，来个例子看看：
@Test
public void test()
{
ArrayList list=new ArrayList();
list.add(1);
list.add(2);
list.add(3);
list.add(3);
System.out.println("list的输出结果:"+list);
}
正如输出结果：两个完全相同的，所以ArrayList是可以存储可重复的数据的，接下来就看看源码：
源码分析：以java8为例
- 1.首先数组是可以存储重复的数据的，
- 2.如果ArrayList在添加的时候，没有进行过滤，那么他就是可以存储重复的数据。
public boolean add(E e) {
//size为添加前数据元素的个数，加一以后，代表加上新添加的元素的长度
//该方法主要作用是：判断是否开辟了空间，判断是否扩容,此处省略，问题2会详细讲述
ensureCapacityInternal(size + 1);
//将elementData的下一份元素赋值为e
elementData[size++] = e;
//返回true
return true;
}
//minCapacity长度：为ArrayList添加新元素后的长度。
private void ensureCapacityInternal(int minCapacity) {
//这里暂时略过，后续在java7和java8的时候会讲
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
//带上minCapacity形参，去下面的方法
ensureExplicitCapacity(minCapacity);
}
//minCapacity长度：为ArrayList添加新元素后的长度。
private void ensureExplicitCapacity(int minCapacity) {
//这是一个快速失败机制，此处略过
modCount++;
//判断数组长度，如果不够就扩容，此处省略后续会讲
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
4.为什么是线程不安全的？
有理有据，看源码
正如下面的图是笔者随意截取的一张图，发现方法中并没有synchronized关键字，所以是线程不安全的。
问题二：是不是感觉ArrayList与数组非常相似?那么为什么ArrayList不会下标越界呢？那ArrayList底层做了什么呢？
1.是不是感觉ArrayList与数组非常相似?
这个问题：相信大家都了解了，因为在前面已经看到了ArrayList底层就是采用elementData这个成员变量进行存储的。
2.那么为什么ArrayList不会下标越界呢？那ArrayList底层做了什么呢？
因为在ArrayList底层封装了自动扩容的规则.
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
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 final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
上面的代码块，就是对底层elementData进行扩容，大概逻辑如下：
- 将数组的长度扩容oldCapacity + (oldCapacity >> 1);扩容1.5倍,因为是有符号的右移，缩小一倍。>>是位运算符，效率贼高。
- 如果扩容1.5倍以后，还是不够用，那么就把形参的值 (因为在add()方法中已经把要添加的元素的长度加入了进入，所以该值是扩容后应该的长度) 直接赋值给数组长度
- 判断是否大于MAX_ARRAY_SIZE (这是int的最大值-8)，如果比这个大，就把int的最大值给他，如果不够，就抛异常。
继续看，加油，你看得累，我写也很累，后面有更精彩的干货。、
了解了扩容以后，记住扩容的方法名字**grow(int minCapacity)**继续往下看添加的流程
public boolean add(E e) {
//size为添加前数据元素的个数，加一以后，代表加上新添加的元素的长度
//该方法主要作用是：判断是否开辟了空间，判断是否扩容,此处省略，问题2会详细讲述
ensureCapacityInternal(size + 1);
//将elementData的下一份元素赋值为e
elementData[size++] = e;
//返回true
return true;
}
//minCapacity长度：为ArrayList添加新元素后的长度。
private void ensureCapacityInternal(int minCapacity) {
//这里暂时略过，后续在java7和java8的时候会讲
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
//带上minCapacity形参，去下面的方法
ensureExplicitCapacity(minCapacity);
}
//minCapacity长度：为ArrayList添加新元素后的长度。
private void ensureExplicitCapacity(int minCapacity) {
//这是一个快速失败机制，此处略过
modCount++;
//判断数组长度，如果不够就扩容，此处省略后续会讲
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
在添加的方法的最底部，发现每次添加添加操作的时候，都会调用grow(int minCapacity)方法，所以每次向ArrayList添加元素的时候，都会判断，如果长度不够，就调用扩容的这个方法进行扩容。
问题三：如题：从java7到java8进行了哪些迭代？为什么要这样做？
针对于java7和java8的对比，主要是针对于构造器和add方法进行的提升。
可能你累了，但是此时我也类，继续看下去，你就可以自己手写一个简单的ArrayList
1. java8的ArrayList是什么样子的？
构造器
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
经过查看源码的无参构造器，创建ArrayList对象时，仅仅给成员变量elementData赋值了一个{}，记住这里：java8的构造器并没有对成员变量elementData进行开辟默认长度是10的数组
add方法
接下来，详细解析add方法，你准备好了吗？
public boolean add(E e) {
//size为添加前数据元素的个数，加一以后，代表加上新添加的元素的长度
//该方法主要作用是：判断是否开辟了空间，判断是否扩容,此处省略，问题2会详细讲述
ensureCapacityInternal(size + 1);
//将elementData的下一份元素赋值为e
elementData[size++] = e;
//返回true
return true;
}
//minCapacity长度：为ArrayList添加新元素后的长度。
private void ensureCapacityInternal(int minCapacity) {
//这里暂时略过，后续在java7和java8的时候会讲
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
//带上minCapacity形参，去下面的方法
ensureExplicitCapacity(minCapacity);
}
//minCapacity长度：为ArrayList添加新元素后的长度。
private void ensureExplicitCapacity(int minCapacity) {
//这是一个快速失败机制，此处略过
modCount++;
//判断数组长度，如果不够就扩容，此处省略后续会讲
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
源码大意：
- 因为默认实例化的时候，并没有创建对象，所以在ensureCapacityInternal(int minCapacity) 方法 中，进行了判断，如果第一次的话，就创建对象。
2.java7的ArrayList是什么样子的？
构造器
public ArrayList(int initialCapacity) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
}
public ArrayList() {
this(10);
}
经过查看源码的无参构造器，发现无参的构造器调用了有参的构造器，传入了一个10作为参数，然后有参的构造器创建一个长度为10的Object类型的数组，赋值给成员变elementData
add方法
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
源码大意：
- 因为默认实例化的时候，为成员变量elementData创建了长度为10的Object数组，所以在ensureCapacityInternal(int minCapacity) 方法 仅仅判断是否需要扩容，没有判断其其否为{}
3.Java7->8的变化(总结)
| JDK7 | JDK8 | |
|---|---|---|
| 构造器 | 实例化即开辟数组长度为10的内存空间 | 实例化时不开辟内存空间 |
| add()方法 | 直接添加 | 第一次调用add方法时，开辟数组长度为10的内存空间 |
问题四：如何高效的使用ArrayList?
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);
}
}
源码大意 如果你给了一个长度，则会直接创建一个你给的长度的Object类型数组，赋值给成员变量elementData，这样就减少了扩容的次数，从而提高效率。