jdk_Collection_ArrayList源码

package com.collection.List;


import java.util.Arrays;
import java.util.Collection;
import java.util.ConcurrentModificationException;
import java.util.NoSuchElementException;
import com.collection.Iterotor.Iterator;


public class ArrayList<E> implements List<E> {
private transient Object[] elementData;
private int size;
private int modCount;
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
 
public ArrayList() {
       this(10);
   }

public ArrayList(int initialCapacity) {
super();
       if (initialCapacity < 0)
           throw new IllegalArgumentException("Illegal Capacity: "+
                                              initialCapacity);
       this.elementData = new Object[initialCapacity];
}


@Override
public boolean add(Object e) {
   ensureCapacityInternal(size + 1); 
   elementData[size++] = e;
        return true;
}


private void ensureCapacityInternal(int minCapacity) {
modCount++;//被修改次数
 
if(minCapacity-elementData.length>0)
{
grow(minCapacity);
}

}


private void grow(int minCapacity) {
int oldCapacity = elementData.length;
int newCapacity = oldCapacity+(oldCapacity>>1); //1.5倍增加新容量

if(newCapacity-minCapacity<0)   //新容量 不够装 所需容量  ----->所需容量赋值给 新容量
{
newCapacity = minCapacity;
}
if (newCapacity - MAX_ARRAY_SIZE > 0) //新容量大于（Integer最大-8）
{
           newCapacity = hugeCapacity(minCapacity);
}
elementData = Arrays.copyOf(elementData, newCapacity);
}


private int hugeCapacity(int minCapacity) {
//下标是否越界(当最大Integer在加1 为负数 此处判断越界)    当前所需容量大于（Integer最大-8） 赋值为最大Integer  否则当前容量是  （Integer最大-8）
if (minCapacity < 0) // overflow
           throw new OutOfMemoryError();
       return (minCapacity > MAX_ARRAY_SIZE) ?
           Integer.MAX_VALUE :
           MAX_ARRAY_SIZE;
}


@Override
public E get(int index) {
if(index>=size)
{
System.out.println("下标索引有错误");
}

return elementData(index);
}


private E elementData(int index) {
// TODO Auto-generated method stub
return (E) elementData[index];
}


@Override
public int size() {
// TODO Auto-generated method stub
return size;
}


@Override
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
       int numNew = a.length;
       ensureCapacityInternal(size + numNew);  // Increments modCount //扩容方法
       System.arraycopy(a, 0, elementData, size, numNew);//复制  新数组内容到容器上
       size += numNew;
       return numNew != 0;
}


private boolean addAll(int index, Collection<? extends E> c) {
/* rangeCheckForAdd(index);
         int cSize = c.size();
         if (cSize==0)
             return false;


         checkForComodification();
         parent.addAll(parentOffset + index, c);
         this.modCount = parent.modCount;
         this.size += cSize;*/
         return true;
}


@Override
public Iterator<E> iterator() {
// TODO Auto-generated method stub
return new Itr();
}


private class Itr implements Iterator<E> {
        int cursor;       // index of next element to return
        int lastRet = -1; // index of last element returned; -1 if no such
        int expectedModCount = modCount;


        public boolean hasNext() {
            return cursor != size; 
        }


        @SuppressWarnings("unchecked")
        public E next() {
            checkForComodification();
            int i = cursor; //光标默认为0
            if (i >= size)// 当前索引大于 容量 抛异常
                throw new NoSuchElementException();
            Object[] elementData = ArrayList.this.elementData;
            if (i >= elementData.length)//当前索引大于 容量 抛异常
                throw new ConcurrentModificationException();
            cursor = i + 1;
            return (E) elementData[lastRet = i];
        }


        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();


            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException ex) {
                throw new ConcurrentModificationException();
            }
        }


        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }


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; // Let gc do its work 设置为null 让垃圾回收null 最后一位 没用引用的空间


       return oldValue;
   }
 
 
private void rangeCheck(int index) {
       if (index >= size)
           throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
   }
 
private String outOfBoundsMsg(int index) {
       return "Index: "+index+", Size: "+size;
   }


}