也快要秋招了，博客也没有任何的代码，只有几个遇到的问题记录，所以就写些吧，顺便复习下，如果有哪块写的有问题，欢迎大家批评指正。
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
private static final long serialVersionUID = 8683452581122892189L;
//默认的一个初始化数组大小
private static final int DEFAULT_CAPACITY = 10;
//这两个都是空数组，主要是用来初始化容器或者判断某些给的形参数组是否为空
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//实际存放对象的数组
transient Object[] elementData;
//当前的数组中存放的对象的个数
private int size;
//我们平时最常用的无参构造方法
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//比较少用的有参构造方法，直接将给的形参容器复制到我们的arraylist中
public ArrayList(Collection<? extends E> c) {
//将容器转化为数组
elementData = c.toArray();
//容器是否不是空的，给size(也就是当前的arraylist中对象的个数)中赋值。
if ((size = elementData.length) != 0) {
//判断字节码对象是否相等，也就是类型是否一致，字节码对象只会在第一次加载这种类时加载字节码，且只加载一次
if (elementData.getClass() != Object[].class)
//将内置的数组赋值为该容器转化的数组
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
//将内置的数组赋值为空数组
this.elementData = EMPTY_ELEMENTDATA;
}
}
//我们平时常用的add方法
public boolean add(E e) {
//确保容量足够，因为每次添加一个对象，所以给的参数是size+1
//这个方法调用的是最关键的地方，在这之后会调用一个方法将容器的容量扩容
ensureCapacityInternal(size + 1); // Increments modCount!!
//上面已经确保了容量足够，且没有异常
//所以直接给当前数组的不是null的那个最末尾的下表的下一个赋值
//注意:size是真正的当前存储的对象的个数
//而elementData这个数组是很有可能有一部分位置是空的，也就是null
elementData[size++] = e;
return true;
}
//确定容量方法,其内调用了一个确定最小容量和一个确定详细容量两个方法
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
//这个方法内就是判断下elementData是否是空的，是空的就直接判断这个size+1是否比默认的初始容量10大
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
//比较minCapacity是否比10大
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
//总之就是返回一个最小的容量数值
}
//该方法确定当前的容量是否足够，并决定是否增加容量
private void ensureExplicitCapacity(int minCapacity) {
//modCount用来记录修改次数，在迭代器内判断是否出现并发修改异常，这个先不管
modCount++;
//上面也说过了，elementData很可能是有一部分是null
//所以还需要判断一下，elementData是否足够大
//一般添加一个元素，elementData.length和size是一样大的
//但是不排除我们会使用addAll(Collection<?> c)方法
if (minCapacity - elementData.length > 0)
//容量不够，增加容量，将calculateCapacity方法确定的最小容量传入
grow(minCapacity);
}
//增长容量方法
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
//(oldCapacity >> 1)是右移操作，相当于除2
//但是这个是最快的，直接将命令给cpu的，我们平时除2也可以这样，能稍微快点，上过组成原理的同学应该知道
//这里就是得到一个elementData.length的1.5倍的值，准备和minCapacity比较出一个合理的值
int newCapacity = oldCapacity + (oldCapacity >> 1);
//如果这个1.5倍的值大于最小容量，那么我们直接取值最小容量就可以
//没必要用1.5倍的值，数组是固定大小，会浪费内存
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//MAX_ARRAY_SIZE的定义为private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8
//MAX_ARRAY_SIZE已经很大，接近int的极限，如果比这个值还要大
if (newCapacity - MAX_ARRAY_SIZE > 0)
//得出一个容量值，这个值会非常大
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
//这句英文说这个这最小容量通常接近于我们elementData的实际存储对象个数
//大概他觉得我们最长使用的是add(E e)这样的添加很少的元素对象，不会一次添加大量元素对象
//System.arraycopy(original, 0, copy, 0,Math.min(original.length, newLength));
//这个Arrays.copyOf之后会调用上面这一句代码
//original是elementData,newLength是newCapacity,copy是完成扩容后的数组
//最后会return copy，也就是完成了这一次扩容
elementData = Arrays.copyOf(elementData, newCapacity);
}
//比较出一个合适的容量值的方法
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError
("Required array size too large");
//这里Integer.MAX_VALUE这个值可能会报错
//因为jvm会有一个默认的内存大小，这个值为21亿的MAX_VALUE可能会超过这个内存
//和数组下标越界异常类似，但是这回是内存不够，可以调整jdk默认内存解决
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
//知道了add(E e)方法后，其他方法也差不多了
//
public E remove(int index) {
//检查是否超出边界范围，只有一句判断是否判处数组越界异常
//private void rangeCheck(int index) {
// if (index >= size)
// throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
//}
rangeCheck(index);
//同add方法一样，modCount用来记录修改次数
modCount++;
E oldValue = elementData(index);
int numMoved = size - index - 1;
if (numMoved > 0)
//其实ArrayList的改变大小就是靠System.arraycopy这个本地方法完成的
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//清除数组对那个删除对象的引用，垃圾回收器才会回收那个没有引用标记的对象
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
}
上面提到了两个可能会有问题的地方，一个是Integer.MAX_VALUE这个值会使得jvm内存不够分配报异常，一个是modCount记录修改次数，也可能报异常
先说第一个地方
try { int[] a=new int[Integer.MAX_VALUE-2]; System.out.println(a.length); } catch (java.lang.OutOfMemoryError e) { e.printStackTrace(); } try { int[] b=new int[Integer.MAX_VALUE]; System.out.println(b.length); } catch (java.lang.OutOfMemoryError e) { e.printStackTrace(); }
这个代码执行后会报错误，Java heap space是内存快到极限时抛出，Requested array size exceeds VM limit是已经在内存中找不到该内存位置了，解决方法是调整jvm默认分配内存大小
第二个地方modCount，先看这么一段代码
ArrayList<Integer> list=new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
Iterator<Integer> iterator = list.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
list.remove(0);
}
运行后，会 抛出java.util.ConcurrentModificationException，这样的一个异常，为什么会抛出这样的一个异常呢？并没有多个线程同时修改集合啊
先看下Iterator<Integer> iterator = list.iterator()中的iterator是什么
继续往下，看到一个内部类
这个类中的next方法，可以看到调用了checkForComodification方法，下面的if (i >= elementData.length) throw new ConcurrentModificationException();是为了防止多线程修改
调用的checkForComodification方法
到这里知道了，每次ArrayList去增删改元素对象的时候，改变了modCount，而其内部类对象的expectedModCount只是修改前的一个modCount的值，
所以调用next方法时，如果使用ArrayList的增删改，那么就会抛出这么一个异常，解决方法是使用迭代器的remove方法
可以看到，这个remove方法中，expectedModCount和modCount每次都会同步下，所以不会报异常了，但是它只有remove方法，如果想要使用其它方法可以使用list.listIterator()获取一个更加强大的迭代器
其余的get set lastIndexOf等方法的代码行数大都比较少，有兴趣的同学可以自己看下，我也是java新手，写博客更多是为了做个记录，难免有些地方有错误，如果有哪块写的不好，或者有问题，欢迎大家批评指正。