ArrayList源码分析(JDK1.8)

不积跬步,无以至千里;不积小流,无以成江海。从基础做起,一点点积累,加油!

来,首先看一下Java集合类的父子关系(图片转自:http://biancheng.dnbcw.info/1000wen/359774.html):
这里写图片描述

ArrayList的定义

public class ArrayList<E> extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, java.io.Serializable
  • 从ArrayList<\E>可以看出它是支持泛型的,它继承自AbstractList,实现了List、RandomAccess、Cloneable、java.io.Serializable接口。

Collection接口的方法:

List
定义

public interface List<E> extends Collection<E>

List接口方法:

AbstractList提供了List接口的默认实现(个别方法为抽象方法(get方法))。

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E>
//ArrayList中使用的modCount就是AbstractList中声明的
protected transient int modCount = 0;

AbstractList中对于List集合的判断equals()方法

public boolean equals(Object o) {
        if (o == this)
            return true;
        if (!(o instanceof List))
            return false;

        ListIterator<E> e1 = listIterator();
        ListIterator<?> e2 = ((List<?>) o).listIterator();
        while (e1.hasNext() && e2.hasNext()) {
            E o1 = e1.next();
            Object o2 = e2.next();
            if (!(o1==null ? o2==null : o1.equals(o2)))
                return false;
        }
        return !(e1.hasNext() || e2.hasNext());
    }

这个方法我觉得写得特别好,放在这里留着。。。

  • AbstractList继承了AbstractCollection类,实现了List集合的除了get方法之外的所有方法:
  • RandomAccess是一个标记接口,接口内没有定义任何内容。
  • 实现了Cloneable接口的类,可以调用Object.clone方法返回该对象的浅拷贝。
  • 通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。序列化接口没有方法或字段,仅用于标识可序列化的语义。

ArrayList的数据域

    transient Object[] elementData; // non-private to simplify nested class access
    /**
     * The size of the ArrayList (the number of elements it contains).
     */
    private int size;

transient 关键字

  • Java的Serializable提供了一种序列化对象实例的机制。当序列化对象时,可能有一个特殊的对象数据成员,我们不想用Serializable机制来保存它。为了在一个特定对象的一个域上关闭Serializable,可以在这个域前加上关键字transient。
  • transient是Java语言的关键字,用来表示一个域不是该对象序列化的一部分。当一个对象被序列化的时候,transient型变量的值不包括在序列化的表示中,然而非transient型的变量是被包括进去的。

看个列子:

public class Person implements Serializable{

    private static final long serialVersionUID = -3319659493471806232L;
    private String name;
    private transient String pass;

    public Person(String name, String pass) {
        this.name = name;
        this.pass = pass;
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", pass=" + pass + "]";
    }
}

public class TestTransient {
    public static void main(String[] args) {
        Person person = new Person("Tome", "1234");
        System.out.println(person);
        try {
            // 序列化,被设置为transient的属性没有被序列化
            ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream(
                    "person.out"));
            o.writeObject(person);
            o.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            // 重新读取内容
            ObjectInputStream in = new ObjectInputStream(new FileInputStream(
                    "person.out"));
            Person readPerson = (Person) in.readObject();
            // 读取后psw的内容为null
            System.out.println(readPerson.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
/**运行结果
*Person [name=Tome, pass=1234]
*Person [name=Tome, pass=null]
*/

被标记为transient的属性在对象被序列化的时候不会被保存。

构造方法分析

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
private static final Object[] EMPTY_ELEMENTDATA = {};

public MyArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

public MyArrayList(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(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;
    }
}

三个构造方法:

  • 无参构造方法
    • 使用无参构造方法创建的是一个length为0的内部数组,当第一次插入数据时,会对其扩容,扩容为默认的大小10
  • 带有初始容量的构造方法
    • 创建一个默认容量的数组
  • 带有初始集合的构造方法

add(E e)方法

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // 检查是否需要扩容
    elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
    //如果创建ArrayList时用的是无参构造器,则第一次插入时会进行一次扩容并且扩到默认数组大小10
    //然而如果是使用带有容量参数的构造器且initialCapacity=0时,则不会进行这一步,直接扩展数组容量为minCapacity
    //这就导致一个结果,扩容之后带参数的构造器的数组length为1,而默认的为10
    //所以,带容量参数的初始化时注意自己需要的大小
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}
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);
}

容量的拓展将导致数组元素的复制,多次拓展容量将执行多次整个数组内容的复制。若提前能大致判断list的长度,调用ensureCapacity调整容量,将有效的提高运行速度。

可以理解提前分配好空间可以提高运行速度,但是测试发现提高的并不是很大,而且若list原本数据量就不会很大效果将更不明显。

add(int index, E element)

    public void add(int index, E element) {
        rangeCheckForAdd(index);//检查index是否越界

        ensureCapacityInternal(size + 1);  // 确保容量
        System.arraycopy(elementData, index, elementData, index + 1,//将index以后的元素后移一个
                         size - index);
        elementData[index] = element;
        size++;
    }
    private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)//元素可以添加在最后尾端
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
    //本地的C/C++库方法,直接操纵内存,速度更快
    public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

indexOf(Object o)

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;
}

remove(int index)

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; // 将对象的引用置为null,让垃圾回收器可以回收

    return oldValue;
}
//删除等其他操作和插入不同,插入可以将元素插在最后面,而删除等操作是在原有的元素上做修改,所以范围检查不一样
private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

clear()

public void clear() {
    modCount++;

    // 清空让垃圾回收器清理
    for (int i = 0; i < size; i++)
        elementData[i] = null;

    size = 0;
}

clone()

返回此 ArrayList 实例的浅表副本。(不复制这些元素本身。)

    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);
        }
    }

调用父类的clone方法返回一个对象的副本,将返回对象的elementData数组的内容赋值为原对象elementData数组的内容,将副本的modCount设置为0。

removeRange(int fromIndex, int toIndex)

    protected void removeRange(int fromIndex, int toIndex) {
        modCount++;
        int numMoved = size - toIndex;
        System.arraycopy(elementData, toIndex, elementData, fromIndex,
                         numMoved);

        // clear to let GC do its work
        int newSize = size - (toIndex-fromIndex);
        for (int i = newSize; i < size; i++) {
            elementData[i] = null;
        }
        size = newSize;
    }

执行过程是将elementData从toIndex位置开始的元素向前移动到fromIndex,然后将toIndex位置之后的元素全部置空顺便修改size。

        ArrayList<Person> arrayList = new ArrayList<Person>();
        arrayList.add(new Person(2));
        arrayList.add(new Person(3));
        arrayList.add(new Person(4));
        arrayList.add(new Person(5));
        arrayList.add(new Person(6));
        arrayList.subList(2, 4).clear();

上面这段代码的运行结果与removeRange(2, 4)一样,原因是:

arrayList.subList(2, 4)创建一个AbstractList的子类SubList的实例,调用clear方法时由于子类SubList没有重写,所以直接调用AbstractList的clear方法,然而,在AbstractList的clear方法中,调用的是removeRange方法,该方法在SubList中重写了;所以,调用的是子类的removeRange,在SubList中有一个指向外部类的指针parent,在removeRange方法中通过parent调用了外部类的removeRange方法。所以经过辗转调用,最终调用的还是外部类的removeRange方法

    public List<E> subList(int fromIndex, int toIndex) {
        subListRangeCheck(fromIndex, toIndex, size);
        return new SubList(this, 0, fromIndex, toIndex);
    }
    //SubList类中没有重写AbstractList的clear方法
    private class SubList extends AbstractList<E> implements RandomAccess {
        private final AbstractList<E> parent;//指向外部类
        private final int parentOffset;
        private final int offset;
        int size;

        SubList(AbstractList<E> parent,
                int offset, int fromIndex, int toIndex) {
            this.parent = parent;
            this.parentOffset = fromIndex;
            this.offset = offset + fromIndex;
            this.size = toIndex - fromIndex;
            this.modCount = ArrayList.this.modCount;
        }
        ...
        protected void removeRange(int fromIndex, int toIndex) {
            checkForComodification();
            parent.removeRange(parentOffset + fromIndex,parentOffset + toIndex);
         //调用外部类的removeRange(),所以最终修改的就是外部类数组的元素,即相当于调用了外部类的removeRange方法
            this.modCount = parent.modCount;
            this.size -= toIndex - fromIndex;
        }
    }
    //AbstractList类中申明的clear()方法
    public void clear() {
        removeRange(0, size());//由于SubList重写了removeRange方法,所以调用SubList的removeRange方法,
    }

每一次对数组做添加元素,删除元素等改变数组大小或者容量的操作时都会引起对modCount的加1, 究竟这个值有什么作用呢?

//返回一个遍历的指针
public Iterator<E> iterator() {
    return new Itr();
}
private class Itr implements Iterator<E> {
    int cursor; // 下一个要返回的元素的下标
    int lastRet = -1; // 最后一个元素的下标
    int expectedModCount = modCount;  //这个的作用就是当用itr来遍历集合时,不允许往里面添加或者删除元素

    public boolean hasNext() {//hasNext方法不会检查expectedModCount 的值,不会引发ConcurrentModificationException异常
        return cursor != size;
    }

    @SuppressWarnings("unchecked")
    public E next() {//next方法在最开始的时候就会使用checkForComodification进行检查
    //所以如果在调用next之前对集合进行了改变则会抛出异常
        checkForComodification();//检查是否改变
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = MyArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i + 1;
        return (E) elementData[lastRet = i];
    }
    //remove方法首先会调用checkForComodification进行检查
    //同时,在MyArrayList.this.remove(lastRet)时会改变modCount,expectedModCount = modCount
    //又让情况变为正常,所以删除之后这两个的值又会想等,在之后调用next的方法时不会炮竹异常
    public void remove() {
        if (lastRet < 0)
            throw new IllegalStateException();
        checkForComodification();

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

    @SuppressWarnings("unchecked")
    public void forEachRemaining(Consumer<? super E> consumer) {
        Objects.requireNonNull(consumer);
        final int size = MyArrayList.this.size;
        int i = cursor;
        if (i >= size) {
            return;
        }
        final Object[] elementData = MyArrayList.this.elementData;
        if (i >= elementData.length) {
            throw new ConcurrentModificationException();
        }
        while (i != size && modCount == expectedModCount) {
            consumer.accept((E) elementData[i++]);
        }
        // update once at end of iteration to reduce heap write traffic
        cursor = i;
        lastRet = i - 1;
        checkForComodification();
    }

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

ArrayList的三种遍历

  • 使用下标(在遍历的时候可以对集合进行添加删除)
        MyArrayList<Integer> array = new MyArrayList<Integer>();
        array.add(1);
        array.add(2);
        array.add(1, 3);
        array.display();

        for(int i = 0; i < array.size(); i++){
            System.out.println(array.get(i));
            array.remove(new Integer(3));
            if (i == 1) {
                array.add(1);
            }
        }
  • 使用iterator
        Iterator<Integer> it = array.iterator();
        while(it.hasNext()){
            //array.add(4);  会导致modCount发生变化,从而导致next方法的checkModCount抛出异常
            int value = it.next();
            //array.remove(new Integer(value));同样会导致modCount发生变化
            it.remove();//但是可以这样,因为Iterator的remove方法删除元素之后对modCount又进行了复原
            System.out.println(value);
        }
  • 使用forEach循环(其实本质就是利用的Iterator循环)先是it.hasNext(),然后在将value = it.next(),所以执行这段代码时,会先打印第一个值,在进行第二轮循环的value = it.next()时抛出异常
        for(Integer value : array){
            //array.add(4);//发生错误
            //array.remove(value);
            System.out.println(value);
        }

本文参考:http://www.cnblogs.com/hzmark/archive/2012/12/20/ArrayList.html
今天看了大牛的代码很开心,明天再接再厉,加油。感受大牛的风采~~

没有更多推荐了,返回首页