java集合之ArrayList源码解析（java8）

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/m0_37293461/article/details/82883607

在java集合框架中，ArrayList应该是最常用的一种了。
ArrayList底层是用数组实现的存储。特点是查询效率高，增删效率低，线程不安全。
最近准备秋招把基础的部分都过了一遍，集合框架这一块也是反复看了ArrayList和HashMap的源码，并重写了这两个实现类。

一，测试ArrayList，了解常用的方法

public class TestArrayList {

    public static void main(String[] args) {
        test();
    }
    
   public static void test(){
       List<String> list = new ArrayList();    //泛型为字符串
       list.add("a");
       list.add("b");
       list.add("c");
       list.add("d");
       System.out.println(list);      //打印

       list.add(2,"yan");      //在2位置插入，后面的数后移
       System.out.println(list);

       list.remove(2);       //移除2位置
       System.out.println(list);

       list.set(2,"yan");       //替换2位置
       System.out.println(list);

       System.out.println(list.get(2));     //获取第二个元素

       System.out.println(list.indexOf("a"));        //集合中有该元素就返回第一次出现的index，没有就返回-1

       list.add("b");
       System.out.println(list.indexOf("b"));          //返回第一个对应的索引
       System.out.println(list.lastIndexOf("b"));    //返回最后一个对应的索引
     }
   }

//output：

二，ArrayList中的数据结构

学习源码时，都会涉及到数据结构，而数据结构往往是程序的精髓所在。ArrayList的数据结构是数组，但是它跟数组不同的地方是ArrayList有一种扩容机制，所以能过自动扩容。妈妈再也不用担心我的容量不够了。
ArrayList的查询速率高，增删效率低，线程不安全。Vector是线程安全的，但是性能不及ArrayList，它们俩的底层实现都是数组。增删一般用HashMap，HashMap是最常用到的集合框架，它的底层实现是链表。

三，ArrayList的核心方法

• 1，继承结构

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

我们可以很清晰的看出，ArrayList先继承了AbstractList，然后分别实现List, RandomAccess, Cloneable, java.io.Serializable三个接口。
List接口
RandomAccess接口 ：用来快速存取，提高性能的。
Cloneable接口：实现了该接口，就可以使用Object.Clone()方法了。
Serializable接口：实现该序列化接口，表明该类可以被序列化，什么是序列化？简单的说，就是能够从类变成字节流传输，然后还能从字节流变成原来的类。
这里为什么没有让ArrayList直接实现List接口呢？反而让ArrayList继承AbstractList，然后AbstractList再实现List接口。其实这是java大牛设计jdk时就考虑到的问题，设计的思想是简洁可读性。
接口中全都是抽象的方法，而抽象类中可以有抽象方法，还可以有具体的实现方法，正是利用了这一点，让AbstractList是实现接口中一些通用的方法，而具体的类还可以添加自己独特的方法。

• 2，类中的属性

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.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 = {};
    //存放元素的数组，包访问权限。这是ArrayList的核心数组
    transient Object[] elementData;
    //大小，创建对象时Java会将int初始化为0
    private int size;
}

• 3，构造方法

 /**
   * 有参构造方法
   * 用指定的数设置初始化容量的构造函数，负数会抛出异常
 */
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);
        }
    }


 /**
   *无参构造方法，用的最多
   *默认构造方法，创建一个 空的 ArrayList，此时其内数组缓冲区 elementData = {}, 长度为 0
   *当元素第一次被加入时，扩容至默认容量 10
 */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }


 /**
   * 创建一个包含collection的ArrayList,放入ArrayList中的集合，全部的元素会添加到新建的ArrayList实例中
   * 这个构造方法用的最少
   * 当参数 c 为 null 时抛出异常
 */
    public ArrayList(Collection<? extends E> c) {
     //将集合转化成Object[]数组
        elementData = c.toArray();
      //把转化后的Object[]数组长度赋值给当前ArrayList的size，并判断是否为0
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            //如果c.toArray不会返回Object[]，则可以查看6260652代码的bug，在官方文档里看
            if (elementData.getClass() != Object[].class)
               //若 c.toArray() 返回的数组类型不是 Object[]，则利用 Arrays.copyOf(); 来构造一个大小为 size 的 Object[]数组
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            //替换为空数组
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

• 4，核心方法
  • 4.1，add()方法（这里详细说明两个，其它都差不多）
    4.1.1，boolean add(E e)； 默认在数组末尾添加元素

 /**
     *增加指定的元素到ArrayList的最后位置
     * @param e 要添加的元素
     */
    public boolean add(E e) {
         //确定ArrayList容量大小
         //size+1，保证资源空间不被浪费
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //按需分配空间资源
        elementData[size++] = e;
        return true;
     }

 /**
     * 私有方法：明确 ArrayList 的容量，提供给本类使用的方法
     * - 用于内部优化，保证空间资源不被浪费：尤其在 add() 方法添加时起效
     *  minCapacity    指定的最小容量
     *  童鞋们可以研究下 童鞋们可以研究下calculateCapacity()方法，也很简单的()方法，也很简单的
    */
    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
      }

    /**
     * 也是私有方法：明确 ArrayList 的容量
     * - 用于内部优化，保证空间资源不被浪费：尤其在 add() 方法添加时起效
     * minCapacity    指定的最小容量
     */
    private void ensureExplicitCapacity(int minCapacity) {
      // 将“修改统计数”+1，该变量主要是用来实现fail-fast机制的
        modCount++;
      // 防止数组容量不够：确保指定的最小容量 > 数组缓冲区当前的长度
      // 不够自动扩容，调用grow()方法
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
      }

  /**
     * 私有方法：扩容，以确保 ArrayList 至少能存储 minCapacity 个元素
     *  扩容计算：newCapacity = oldCapacity + (oldCapacity >> 1);  十进制数转二进制右移操作
     *  这里的扩容算法和jdk6不一样，jdk6直接是newCapacity = (oldCapacity *3)/2+1
     *  jdk8是在6的基础上进行了算法优化，右移计算效率比直接乘除要高
     *  minCapacity    指定的最小容量
     */
   private void grow(int minCapacity) {
        // 防止容量不够
        // overflow-conscious code
        int oldCapacity = elementData.length;
        // 新容量等于老容量的一点五倍，即进行右移计算
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)   // 若 newCapacity 依旧小于 minCapacity
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)  // 若 newCapacity 大于最大存储容量，则进行大容量分配，分配请看hugeCapacity()方法
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

4.1.2 void add(int，E)；在特定位置添加元素，也就是插入元素

  /**
     *在这个ArrayList中的指定位置插入指定的元素，
     * 在指定位置插入新元素，原先在 index 位置的值往后移动一位
     * index 指定位置
     * element 指定元素
     */
    public void add(int index, E element) {
    //判断角标是否越界	
        rangeCheckForAdd(index);
   //size+1，保证资源空间不浪费，和第一个add方法作用一样
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //数组复制，就是将index之后的所有元素保留，并全部往后移一位，这就是数组插入删除效率低的原因
        // elementData：需要复制的数组是elementData； 
        // index：需要复制的数组从index开始
        // elementData：复制到哪？
        // index + 1：复制到的新数组是从第几个开始存
        // size - index：复制的长度=总长度-索引
        // 最后，新数组将取代之前的数组，旧数组会被GC自动回收
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;    //插入指定位置
        size++;
    }

• 4.2，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);
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }

• 4.3，set()方法

 public E set(int index, E e) {
            rangeCheck(index);
            checkForComodification();
            E oldValue = ArrayList.this.elementData(offset + index);
            ArrayList.this.elementData[offset + index] = e;
            return oldValue;
        }

• 4.4，indexof()方法

    // 从首开始查找数组里面是否存在指定元素
    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;
    }

• 4.5，get()方法

public E get(int index) {
        // 检验索引是否合法
        rangeCheck(index);

        return elementData(index);
    }
    
E elementData(int index) {
        return (E) elementData[index];
    }

5，总结
想你想要