使用arraylist类型存放多个菜谱的信息_ArrayList源码分析与应用场景

1.ArrayList底层实现原理

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

从源码中我们可以看到ArrayList的实现依赖于与AbstractList的继承关系和接口List<E>、RandomAccess、Cloneable和Serializable。另外AbstractList的实现又依赖于其他继承关系与接口，关系图如下。

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源码中定义四个私有域的静态的不可更改的属性。

• serialVersionUID是序列号，因为ArrayList调用了Serializable接口，说明ArrayList可以被序列化，因此需要加上serialVersionUID。
• DEFAULT_CAPACITY是默认的容量大小为10，当需要添加的元素个数小于10的时候，ArrayList的容量大小就一直保持10，如果超出10，ArrayList会进行扩容。
• EMPTY_ELEMENTDATA 是一个Object类型的数组，使用Object来定义数组是因为ArrayList实现了泛型，在类定义中ArrayList<E> 中的E就代表泛型。这就意味着当我们使用时需要指明E的类型，由于所有的类型都继承Object类，因此这里用Object来定义数组。同理下面的DEFAULTCAPACITY_EMPTY_ELEMENTDATA也算这个道理。

接着源码中给出了三个构造方法。

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

构造方法一中需要传入初始的数组队列的容量值，如果容量值大于0，则创建该容量值大小的数组；如果等于0，则为EMPTY_ELEMENTDATA ；若小于0，则抛出异常。

构造方法二中直接创建了一个默认的空object类型的数组。

构造方法三中用Collection对象来创建，最后把集合中的内容放到ArrayList中去。

从上面的分析中我们可以初步看到，ArrayList的实现实际上是基于数组。但是和数组区别的是，我们使用时并不一定需要给定容量大小值，也就是说我们可以把ArrayList看作一个动态的数组，在最大容量大小允许的范围内我们不需要关心它的容量大小，随着我们增加元素或者减少元素，它的容量大小也在发生变化，从而可以节省资源。

2.ArrayList的扩容机制。

ArrayList发生扩容无疑是因为在我们加入了元素，是得ArrayList的大小发生变化，因此我们首先看add方法的源码。

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

从源码中我们可以看到，add方法中调用了ensureCapacityInternal方法，并把原来的size+1。接着我们来看ensureCapacityInternal方法的实现。

 private void ensureCapacityInternal(int minCapacity) {
 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);
    }

我们可以看到ensureCapacityInternal，ensureExplicitCapacity， grow这三个方法一起实现了ArrayList的扩容。其实现过程可以概述为：

首先先判断elementData是不是DEFAULTCAPACITY_EMPTY_ELEMENTDATA，如果是并且elementData的大小要小于ensureCapacityInternal传入的整型数，则elementData的大小就不会改变，保持default capacity的大小为10；反之如果大小超出了10，则会调用grow方法，在grow方法中

int newCapacity = oldCapacity + (oldCapacity >> 1);

这条语句实现了ArrayList的扩容，>>1是位运算，即将oldCapacity的二进制值右移动一位，低位擦除，高位补零，该表达式可以近似为 newCapacity的大小为oldCapacity的1.5倍，也就是说当容量大于10的时候，ArrayList将以1.5倍的速度扩容。

3.ArrayList的应用场景。

区别于数组的功能，ArrayList不光实现了动态地存储元素，还提供了很多方便简单地方法，如增加元素，删除元素，得到元素索引等，而调用这些方法就免去了使用数组时的循环遍历，减少了时间复杂度和占用的内存。特别是要对大数据量进行插入，删除的操作时，ArrayList就会显示出明显的优势。

并且，ArrarList实现了泛型，不光可以存储基本类型的数据，还可以存储我们自己定义的类，这给我们开发提供了极大的方便，尤其当我们需要对很多个类进行操作时。例如对多个对象加线程，我们就不需要同时创建多个对象，对每一个对象都加上一个线程，那会使程序及其卡顿。因此我们可以创建一个ArrayList对象，将其他对象添加到ArrayList中去，对ArrayList对象添加线程就可以实现同样的效果，并且减少卡顿。