java源码(1):ArrayList

 

ArrayList是实现了List接口的一个动态可调节大小的数组可用来存放各种形式的数据，好处：1.动态的增删数据；2.数组的大小动态控制，实现了ICollection和IList接口，看源码：

继承于AbstractList抽象类，但其内部只有一个抽象方法 get()，关于AbstracktList链接: AbstractList详解

实现接口List，RandomAccess，Cloneable，java.io.Serializable。list不用解释，关于RandomAccess 是一个标记接口，用于标明实现该接口的List支持快速随机访问，详细链接:RandomAccess解释

Cloneable重写了Object的clone方法；后面的Java.io.Serializable用来对对象进行序列化，假若某个对象要在网络上传输 
或者要把对象写入文件或从文件读出，那么这个对象就必须实现java.io.Serializable。

再往下走：

看几个重要的属性：

    /**
     * Default initial capacity.
     */

    private static final int DEFAULT_CAPACITY = 10;
    

     /**
     * 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.
     *//百度翻译
     *
     *数组缓冲区，其中存储了arraylist的元素。arraylist的容量是这个数组缓冲区的长度。添加第一个元 
     *素时，elementdata==default capacity_empty_elementdata的任何空arraylist都将扩展为默认的 
     *_capacity。
     */

    transient Object[] elementData; // non-private to simplify nested class access


    /**
     * The size of the ArrayList (the number of elements it contains).
     *ArrayList的大小
     * @serial
     */

    private int size;

初始化大小为10，elementData是存放内容的数组，size表示大小，我们常用的arrayList.size();方法下面就是return size;返回这个值。

再往下初始化方法:

//方法带默认值大小
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);
        }
}


//无参构造方法
public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

//构造方法传入的collection
 public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

有三个构造方法，因为默认的值是10，这里如果没有设置默认值就不设置，如果有则去设置默认值。

再往下

//这个方法就是将arrayList中elementData的大小设置为和当前arrayList中数据的大小相等
public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
}

变量modCount，用于记录对象的修改次数，比如增、删、改，也基本存在于非线程安全的集合类中。

//确保arrayList的容量可以支撑大小为minCapacity
//如果不能支撑，则调用ensureExplicitCapacity来进行让
//Arraylist可以支撑的起它。
public void ensureCapacity(int minCapacity) {
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            // any size if not default element table
            ? 0
            // larger than default for default empty table. It's already
            // supposed to be at default size.
            : DEFAULT_CAPACITY;

        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
}


//给modcount++表示更改了数组大小
//然后调用grow来增长。
private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
}

//grow方法增长了1.5倍在原来的基础上，
//调用Arrays.copyof方法来增长elementData,
//然后再看Arrays.copyof
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);
    }

//

public static <T> T[] copyOf(T[] original, int newLength) {
        return (T[]) copyOf(original, newLength, original.getClass());
    }
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;
}

//System.arraycopy是一个native方法

再继续往下看源码：

//这个方法是检查有没有这个元素的调用的是indexof

public boolean contains(Object o) {
        return indexOf(o) >= 0;
}
​

//这个方法是返回对象o的下标，没有返回-1
public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
}

//
public int lastIndexOf(Object o) {
        if (o == null) {
            for (int i = size-1; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = size-1; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

可以看出这个indexOf和lastindexOf方法的时间复杂度是n

public Object clone() {
        try {
            ArrayList<?> v = (ArrayList<?>) super.clone();
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        }
}

 太多了，先列几个常用方法吧：

//获取位置于index上的元素

public E get(int index) {
        rangeCheck(index);

        return elementData(index);
}

@SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[index];
}

这个elementData方法加了一个注解：@suppressWarnings("unchecked")， @SuppressWarnings("unchecked") 告诉编译器忽略 unchecked 警告信息，如使用List，ArrayList等未进行参数化产生的警告信息。刚查的，你看看这源码看起来还是有点味道的。

 public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

set方法有返回值，返回的是旧的该位置的值。

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

add方法采用 ensureCapacityInternal方法来进行扩容，这个方法上面写了，你看这个方法加了两个感叹号，源码里的注解加的哦。

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; // clear to let GC do its work

        return oldValue;
    }

 这个remove方法删除index后会将后面的往前移动，然后大小减一，就不如linkedList方法好用。

好了，差不多到这了，然后重点就是arrayList扩容的时候，进行了newSize = oldSize+（oldSize >> 1）；这样的骚操作，以及它调用了。