源代码阅读

ArrayList源码分析

jdk 源码模块

 

继承结构和层次

代码：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable{}

1.ArrayList继承这个AbstractList类

2.ArrayList实现了List<E>，RandomAccess，Cloneable，java.io.Serializable等接口

作用：

（1）List<E>接口：一个 List 是一个元素有序的、可以重复、可以为 null 的集合（有时候我们也叫它“序列”）。

（2）RandomAccess接口：

这个是一个标记性接口，通过查看api文档，它的作用就是用来快速随机存取，有关效率的问题，在实现了该接口的话，那么使用普通的for循环来遍历，性能更高，例如arrayList。

（3）Cloneable接口：

实现了该接口，就可以使用Object.Clone()方法了。

（4）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;  //实际元素大小，默认为0
​
 private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;  *// 最大数组容量*

构造

1）无参构造方法：

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

2）有参构造函数一：

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

3）有参构造函数二：

public ArrayList(Collection<? extends E> c) {
    Object[] a = c.toArray();
    if ((size = a.length) != 0) {
        if (c.getClass() == ArrayList.class) {
            elementData = a;
        } else {
            elementData = Arrays.copyOf(a, size, Object[].class);
        }
    } else {
        // replace with empty array.
        elementData = EMPTY_ELEMENTDATA;
    }
}

总结：arrayList的构造方法就做一件事情，就是初始化一下储存数据的容器，其实本质上就是一个数组，在其中就叫elementData。

核心方法

　1）boolean contains(Object o)；//如果这个list中有这个数据就用 indexof(Object o)这个方法返回指定元素第一次出现的索引

public boolean contains(Object o) {
    return indexOf(o) >= 0;
}
public int indexOf(Object o) {
     return indexOfRange(o, 0, size);
    }

2）lastIndexOf(Object o)//返回元素最后一个出现的位置索引

public int lastIndexOf(Object o) {
    return lastIndexOfRange(o, 0, size);
}
​
int lastIndexOfRange(Object o, int start, int end) {
    Object[] es = elementData;
    if (o == null) {
        for (int i = end - 1; i >= start; i--) {
            if (es[i] == null) {
                return i;
            }
        }
    } else {
        for (int i = end - 1; i >= start; i--) {
            if (o.equals(es[i])) {
                return i;
            }
        }
    }
    return -1;
}

3）Object clone()//此{@CodeArrayList}实例的克隆，返回此实例的浅层副本。（*图元本身不会被复制。）

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

4）E get (int index) //返回这个元素的句子位置

public E get(int index) {
    Objects.checkIndex(index, size);
    return elementData(index);
}

5）E set(int index, E element)//用新的元素替换旧的元素

public E set(int index, E element) {
    Objects.checkIndex(index, size);
    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}

6）boolean add(E e)//将指定的元素追加到此列表的末尾

  public boolean add(E e) {
        modCount++;
        add(e, elementData, size);
        return true;
    }