ArrayList源码分析

ArrayList源码分析

如果面试，集合是一个很容易被问到的题，如果这个时候你说，你看过源码，会在面试官心里留下很深刻的印象。也可以在简历上书写，我看过什么什么源码，这样会在其他求职者中脱颖而出。那么我们废话少说，直接杀入我们的主题ArrayLis源码分析

庖丁解牛，必先查其骨（查看成员）

如果要了解，一个源码，首先要看的是它的成员。它的成员是为以后去做准备。

private static final long serialVersionUID = 8683452581122892189L; //每次打开源码，基本上都可以看到serialVersionUID，像这个可以不用关注，它只是序列号，为了让JVM去识别。

   
    private static final int DEFAULT_CAPACITY = 10;//要看这一句，首先要对final有了解，不是熟悉的朋友可以先去看看。这个申请了一个默认初值为10的容量

   
    private static final Object[] EMPTY_ELEMENTDATA = {};//这个让它的集合为空

   
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; //这个是定义个默认集合设置为空


    transient Object[] elementData;  //transient是声明elementData 是短暂的，不能进行序列化

   
    private int size; //申请int类型的size

欲破之，必要视其法（方法）

第一式：任督二脉
首先看下这个构造器

//有参构造器
public ArrayList(int initialCapacity) { //初始化
        if (initialCapacity > 0) { 
            this.elementData = new Object[initialCapacity];//这个elementData就是我们看到的成员
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;  //默认集合为空赋值于elementData
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }
	//空参构造器
	public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

我们从上面看到ArrayList有两种，一种是有参的，一种是无参的。

	 1. 无参的构造器直接把它默认为空。
 	 2. 有参的构造器先将对传入的参数判断，是否大于0，
 	  如果大于0在对它进行申请。小于0就对它进行参数异常。

 public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();//将c通过toArray()赋值给elemnetData
        if ((size = elementData.length) != 0) {//在对elementData.length进行判断，是否为空
           
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
                //如果数组类型不相等，就将Object通过copyof拷贝给elmentData
        } else {
      
            this.elementData = EMPTY_ELEMENTDATA;//否则相等就直接返回空传给它
        }
    }
     public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }

这构造方法，使用的是泛型，如果要进行添加其他集合，可以使用泛型进行限定。

第二式：九阳神功 ----通方法，走江湖 -----------增查删改
1.增add()
这个是我的大概分析，ArrayList是怎么实现自动扩容，通过数组复制进行扩容。

你们下来也看看源代码，自己实际分析一下。

 	  public boolean add(E e) {
        ensureCapacityInternal(size + 1); 
        elementData[size++] = e;
        return true;
    }
	//我们通过查看源码，找到add()方法。如果传入值，会首先调用ensureCapacityInternal(size + 1); 
 private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }


private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        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);
       
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE:MAX_ARRAY_SIZE;
    }

    

2 .查get()
ArrayList的查很简单，因为它的底层是一个数组，数组是一个连续的地址存储，所以ArrayList集合的查询效率很高。如果输入的index大于本身size，就会提示数组越界异常。
下来你们看看源代码。

   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()
改也是十分的简单， rangeCheck(index);这个就是对是否越界的查询。如果越界就和上面类似。对原先的赋值给oldValue，进行返回。在对现在的index，通过 elementData[index] = element;进行修改。
下来你们看看源代码。

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

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

4.删remove()
对于删除, rangeCheck(index);你们已经很熟悉。看到oldValue = elementData(index);还是对删除的值进行记录，进行返回。
下来就到重点，朋友们，准备好。下来就要找到这个点，numMoved = size - index - 1;为什么要找numMoved，因为它是想将数组分成两段，第一段–，第二段++，刚好把要删除的排除在外。再将新的两段赋给旧的数组。那么就会删除成功。
下来你们看看源码。

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; 

        return oldValue;
    }

独孤九剑，必定总其招（总结）

我们对ArrayList进行了CRUD分析，它的底层是一个数组，每次添加就对数组进行扩容，这样会造成系统资源的浪费。但对于查询修改方面，使用数组作为底层，它是一个连续的地址，那么它查询的效率就会十分的高。
*世间上每个东西都不是完美的，它获得了什么，也会丢掉什么。

• 转载请注明来自WindeYang的CSDN博客：链接地址 https://blog.csdn.net/qq_42849511