集合ArrayList

集合----ArrayList

一、ArrayList的属性

 private static final long serialVersionUID = 8683452581122892189L;

    /**
     * Default initial capacity.
     */
    private static final int DEFAULT_CAPACITY = 10;//初始话容量为10

    /**
     * Shared empty array instance used for empty instances.
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};//指定该ArrayList容量为0是返回该空数组

    /**
     * Shared empty array instance used for default sized empty instances. We
     * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
     * first element is added.
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};//默认返回空数组，

    /**
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer. Any
     * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
     * will be expanded to DEFAULT_CAPACITY when the first element is added.
     */
    transient Object[] elementData; //保存添加到ArrayList中的元素，当第一次添加元素进入ArrayList中时，数组将扩容到10，也就是初始容量
// non-private to simplify nested class access

    /**
     * The size of the ArrayList (the number of elements it contains).
     *
     * @serial
     */
    private int size;//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);
        }
    }
//如果没有指定容量就返回默认的数组容量0
public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

1、add方法

//直接添加元素
public boolean add(E e) {
    //检查是否需要扩容
     ensureCapacityInternal(size + 1);  // Increments modCount!!
     //插入元素
     elementData[size++] = e;
     return true;
}
//**********************************************************************************//
private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);//想要得到最小的容量(不浪费资源)
        }
        return minCapacity;
    }
//调用ensureExplicitCapacity()来确定明确的容量
private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);//如果要的最小容量比数组的长度要大，那么就调用grow()来扩容(当添加第11个元素时，minCapcity为11，数组长度为10，那么就要扩容了)
    }
private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);//扩大为原容器大小的1.5倍
        if (newCapacity - minCapacity < 0)//如果第一次扩容后，容量还是小于minCapcity，就将容量扩容为minCapcity
            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);//扩容完后，调用copyOf()方法
    }
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }
//**********************************************************************************//



//添加元素到指定位置
public void add(int index, E element) {
        rangeCheckForAdd(index);//检查角标
    	//空间检查，看是否需要扩容
        ensureCapacityInternal(size + 1);  // Increments modCount!!
    	//将需要插入元素位置之后的复制到扩容后的数组上
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
    	//将元素放入指定位置
        elementData[index] = element;
        size++;
    }

2、get方法

public E get(int index) {
    	//检查角标
        rangeCheck(index);
    	//返回元素
        return elementData(index);
    }
private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
E elementData(int index) {
        return (E) elementData[index];
    }

3、set方法

public E set(int index, E element) {
    	//检查角标
        rangeCheck(index);
		//将值进行替代
        E oldValue = elementData(index);
        elementData[index] = element;
    	//返回旧值
        return oldValue;
    }

4、remove方法

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);
    	//将最后一个值设为null，等待GC回收
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }

三、ArrayList遍历方式

List<String> list = new ArrayList<String>();
//使用Iterator容器迭代遍历
Iterator i = list.iterator();
while(i.hasNext()){
    System.out.println(i.next());
}
//使用foreach遍历
for(String str : list){
    System.out.pringln(str);
}
//for循环遍历
for(int i=0;i<list.size();i++){
    System.out.pringln(list.get(i));
}
//转换为数组遍历
String[] arr = new String[list.size()];
arr = list.toArray();

四、总结

• ArrayList是基于动态数组实现的，在增删时候，需要数组的拷贝复制。
• ArrayList的默然初始容量是10，每次扩容时候增加原先容量的一半，也就是扩容为就是原容量的1.5倍。
• 删除元素时不会减少容量的大小，若希望减少容量的大小可以调用trimToSize()
• ArrayList不是线程安全的。它能存放null值。