java基础-Java集合框架-Collection子接口-List接口以及ArrayList的源码分析

最新推荐文章于 2022-09-05 21:55:20 发布

Shacoray

最新推荐文章于 2022-09-05 21:55:20 发布

阅读量82

点赞数

分类专栏：集合 java 文章标签： java 集合 arraylist

本文链接：https://blog.csdn.net/jllion/article/details/116015842

版权

java 同时被 2 个专栏收录

62 篇文章 1 订阅

订阅专栏

集合

14 篇文章 0 订阅

订阅专栏

Java集合框架-Collection子接口之一-List接口

List接口概述

鉴于Java中数组用来存储数据的局限性，我们通常使用List替代数组
List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引
List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素
JDK API中List接口的实现类常用的有：ArrayList、LinkedList和Vector

比较ArrayList、LinkedList、Vector的异同

相同：
- 三个类都实现了List接口，存储数据的特点相同：存储有序的、可重复的数据
- ArrayList和Vector底层都是使用Object[] 存储
不同：
- ArrayList：为List接口的主要实现类，线程不安全的，效率高；底层使用Object[] 存储
- LinkedList：底层使用双向链表存储，对于频繁的插入、删除的操作，效率比ArrayList高。
- Vector：为List接口的古老实现类，线程安全的，相较于ArrayList效率低；底层使用Object[] 存储

源码：

ArrayList:

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable {
    private static final long serialVersionUID = 8683452581122892189L;
    private static final int DEFAULT_CAPACITY = 10;
    private static final Object[] EMPTY_ELEMENTDATA = new Object[0];
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = new Object[0];
    transient Object[] elementData;
    ...
}

LinkedList：

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
    transient int size = 0;

    /**
     * Pointer to first node.
     * Invariant: (first == null && last == null) ||
     *            (first.prev == null && first.item != null)
     */
    transient Node<E> first;

    /**
     * Pointer to last node.
     * Invariant: (first == null && last == null) ||
     *            (last.next == null && last.item != null)
     */
    transient Node<E> last;
    
    ...
}

Vector：

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    /**
     * The array buffer into which the components of the vector are
     * stored. The capacity of the vector is the length of this array buffer,
     * and is at least large enough to contain all the vector's elements.
     *
     * <p>Any array elements following the last element in the Vector are null.
     *
     * @serial
     */
    protected Object[] elementData;
    ...
}

ArrayList源码分析：

jdk1.6中ArrayList的源码和逻辑：

ArrayList list = new ArrayList();//创建了长度是10的Object[]数组

构造器：


  
    public ArrayList(int initialCapacity) {
        super();
            if (initialCapacity < 0)
                throw new IllegalArgumentException("Illegal Capacity: "+
                                                   initialCapacity);
        this.elementData = new Object[initialCapacity];
    }

    /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
		this(10);
    }

   
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        size = elementData.length;
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    }

添加元素，调用add(E e)方法：
add方法的调用链： add(E e)->ensureCapacity(int minCapacity)
调用步骤解析：
- 先调用ensureCapacity(size + 1)方法，判断是否需要扩容，其中size+1为所需要的元素总个数
- 在ensureCapacity(int minCapacity)方法内，先获取原数组长度赋值给变量oldCapacity（int oldCapacity = elementData.length;）
- 对比所需的数组长度和原数组长度做对比，如果原数组长度大于所需数组长度，表示数组不需要扩容，结束ensureCapacity方法
- 如果原数组长度小于所需数组长度，则表示原数组不够用需要扩容，进入扩容流程
- 扩容流程，先获取原数组内容赋值带Object oldData[]局部变量用于，后续把存量数据复制到新数组中(但后面没用到。。。这部分代码无用)
- 计算新的数组的容量为原数组长度的1.5倍加1赋值给变量新数组长度newCapacity，计算公式为int newCapacity = (oldCapacity * 3)/2 + 1;
- 再次判断新数组newCapacity与所需数组长度的大小，如果此时还不够（newCapacity<minCapacity），则直接将minCapacity赋值给newCapacity
- 最后调用Arrays.copyOf(elementData,newCapacity);生成新的数组

源码：

    //记录集合修改此时，用于多线程操作下，fast-fail的判断
    protected transient int modCount = 0;
 
    public boolean add(E e) {
        //判断是否需要扩容
        ensureCapacity(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
   //判断是否需要扩容
   public void ensureCapacity(int minCapacity) {
        modCount++;
        //获取原数组长度
        int oldCapacity = elementData.length;
        //对比所需数组长度和原数组长度
        if (minCapacity > oldCapacity) {
            //所需数组长度大于原数组长度，此时长度不够需要扩容
            Object oldData[] = elementData;
            //新数组长度为原数组长度的1.5倍+1
            int newCapacity = (oldCapacity * 3)/2 + 1;
            //判断新数组长度是否够
           if (newCapacity < minCapacity)
               //如果还不够，则直接将所需长度赋值给新数组长度
            newCapacity = minCapacity;
            // 创建新数组，将就数组已有的元素复制给新的数组
            elementData = Arrays.copyOf(elementData, newCapacity);
        }
   }

jdk1.7中ArrayList的源码和逻辑
- ArrayList list = new ArrayList();//创建一个空的数组，长度为0，第一次添加元素的时候再进行扩容
- 首先会将elementData赋值成一个长度为0的空的数组
- 构造器
  - ```
  	
  public ArrayList(int initialCapacity) {
      super();
      if (initialCapacity < 0)
          throw new IllegalArgumentException("Illegal Capacity: "+
                                             initialCapacity);
      this.elementData = new Object[initialCapacity];
  }
  
  /**
   * 空的长度为10的数据
   * 先不初始化
   */
  public ArrayList() {
      super();
      this.elementData = EMPTY_ELEMENTDATA;
  }
  
  public ArrayList(Collection<? extends E> c) {
      elementData = c.toArray();
      size = elementData.length;
      // c.toArray might (incorrectly) not return Object[] (see 6260652)
      if (elementData.getClass() != Object[].class)
          elementData = Arrays.copyOf(elementData, size, Object[].class);
  }
```
- 添加元素，调用add(E e)方法：
- add(E e)方法的调用链: add(E e)->ensureCapacityInternal(int minCapacity)->ensureExplicitCapacity(int minCapacity)->grow(int minCapacity)->hugeCapacity(int minCapacity)
- 调用步骤解析：
  - 在add()方法中先调用ensureCapacityInternal(int minCapacity)方法,判断是否需要初始化或者扩容
  - 在ensureCapacityInternal(int minCapacity)方法进行初步扩容逻辑，先判断当前list容器中的elementData数组属性是否为EMPTY_ELEMENTDATA。
    - 如果是，则进行初始化长度的计算，初始化长度计算逻辑是比较默认数组长度DEFAULT_CAPACITY和所需要的数组长度minCapacity
    - 取较大的值作为初始化长度赋值给minCapacity
  - 然后在ensureCapacityInternal(int minCapacity)方法中，调用ensureExplicitCapacity(int minCapacity)方法，进行扩展扩容逻辑
  - 在ensureCapacityInternal(int minCapacity)方法中，判断minCapacity和当前容器底层数组的长度进行比较if(minCapacity - elementData.length >0)，如果小于等于则不进行扩容
  - 如果(minCapacity -elementData.length > 0),则进行扩容操作，调用grow(int minCapacity)方法
  - 在grow(int minCapacity)方法中，先获取当前容器底层数组中的elementData的长度，作为旧的容器长度赋值给oldCapacity
  - 进行扩容计算，将旧的容器长度oldCapacity的1.5倍作为新容器的长度赋值给newCapacity（ int newCapacity = oldCapacity + (oldCapacity >> 1);）
  - 对比新容器长度newCapacity与所需容器长度minCapacity的大小，如果minCapacity仍然大于newCapacity，则直接将minCapacity作为扩容大小赋值给newCapacity(这里的操作是为了add操作成功做一个保障)
  - 然后判断newCapacity与容器允许的最大长度MAX_ARRAY_SIZE的大小比较（这步操作也是做一个保障，避免容器大小太大，如果太大则直接抛出OutOfMemery异常），MAX_ARRAY_SIZE大小为Integer.MAX_VALUE - 8（使用Integer.MAX_VALUE - 8是为了在提前于oom做判断）
  - 如果newCapacity - MAX_ARRAY_SIZE > 0则调用 hugeCapacity(int minCapacity)方法进行大容器扩容。
    - 如果newCapacity < 0 (此时的小于0，已经可以判断为超过了Integer的最大值)，则抛出OutOfMemoryError异常
    - 如果newCapacity > 0则判断newCapacity和 MAX_ARRAY_SIZE大小
      - newCapacity > MAX_ARRAY_SIZE,容器的扩容大小将是Integer.MAX_VALUE
      - newCapacity <= MAX_ARRAY_SIZE,容器的扩容大小将是MAX_ARRAY_SIZE（此时只有等于的情况）
  - 最后调用Arrays.copyOf(elementData,newCapacity)，将原容器底层数组的元素赋值到新扩容的容器底层数组中
- 源码：
  - ```
  public boolean add(E e) {
      ensureCapacityInternal(size + 1);  // Increments modCount!!
      elementData[size++] = e;
      return true;
  }
  
  private void ensureCapacityInternal(int minCapacity) {
      if (elementData == 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);
  }
  
  private static int hugeCapacity(int minCapacity) {
      if (minCapacity < 0) // overflow
          throw new OutOfMemoryError();
      return (minCapacity > MAX_ARRAY_SIZE) ?
          Integer.MAX_VALUE :
          MAX_ARRAY_SIZE;
  }
```

jdk1.8中ArrayList的源码和逻辑：

ArrayList list = new ArrayList();//创建一个空的数组，长度为0，第一次添加元素的时候再进行扩容
首先会将elementData赋值成一个长度为0的空的数组

构造器：

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

/**
 * Constructs an empty list with an initial capacity of ten.
 */
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

/**
 * Constructs a list containing the elements of the specified
 * collection, in the order they are returned by the collection's
 * iterator.
 *
 * @param c the collection whose elements are to be placed into this list
 * @throws NullPointerException if the specified collection is null
 */
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;
    }
}

添加元素，调用add(E e)方法：
add(E e)方法的调用链: add(E e)->ensureCapacityInternal(int minCapacity)->ensureExplicitCapacity(int minCapacity)->grow(int minCapacity)->hugeCapacity(int minCapacity)
调用步骤解析(add方法的调用解析和1.7大同小异，区别在于提取了第一次add的初始化方法calculateCapacity)：
- 在add()方法中先调用ensureCapacityInternal(int minCapacity)方法,判断是否需要初始化或者扩容
- 在ensureCapacityInternal(int minCapacity)方法进行初步扩容逻辑，先调用(Object[] elementData, int minCapacity)判断当前list容器中的elementData数组属性是否为EMPTY_ELEMENTDATA。
  - 如果是，则进行初始化长度的计算，初始化长度计算逻辑是比较默认数组长度DEFAULT_CAPACITY和所需要的数组长度minCapacity
  - 取较大的值作为初始化长度赋值给minCapacity
- 然后在ensureCapacityInternal(int minCapacity)方法中，调用ensureExplicitCapacity(int minCapacity)方法，进行扩展扩容逻辑
- 在ensureCapacityInternal(int minCapacity)方法中，判断minCapacity和当前容器底层数组的长度进行比较if(minCapacity - elementData.length >0)，如果小于等于则不进行扩容
- 如果(minCapacity -elementData.length > 0),则进行扩容操作，调用grow(int minCapacity)方法
- 在grow(int minCapacity)方法中，先获取当前容器底层数组中的elementData的长度，作为旧的容器长度赋值给oldCapacity
- 进行扩容计算，将旧的容器长度oldCapacity的1.5倍作为新容器的长度赋值给newCapacity（ int newCapacity = oldCapacity + (oldCapacity >> 1);）
- 对比新容器长度newCapacity与所需容器长度minCapacity的大小，如果minCapacity仍然大于newCapacity，则直接将minCapacity作为扩容大小赋值给newCapacity(这里的操作是为了add操作成功做一个保障)
- 然后判断newCapacity与容器允许的最大长度MAX_ARRAY_SIZE的大小比较（这步操作也是做一个保障，避免容器大小太大，如果太大则直接抛出OutOfMemery异常），MAX_ARRAY_SIZE大小为Integer.MAX_VALUE - 8（使用Integer.MAX_VALUE - 8是为了在提前于oom做判断）
- 如果newCapacity - MAX_ARRAY_SIZE > 0则调用 hugeCapacity(int minCapacity)方法进行大容器扩容。
  - 如果newCapacity < 0 (此时的小于0，已经可以判断为超过了Integer的最大值)，则抛出OutOfMemoryError异常
  - 如果newCapacity > 0则判断newCapacity和 MAX_ARRAY_SIZE大小
    - newCapacity > MAX_ARRAY_SIZE,容器的扩容大小将是Integer.MAX_VALUE
    - newCapacity <= MAX_ARRAY_SIZE,容器的扩容大小将是MAX_ARRAY_SIZE（此时只有等于的情况）
- 最后调用Arrays.copyOf(elementData,newCapacity)，将原容器底层数组的元素赋值到新扩容的容器底层数组中

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

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

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

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
    MAX_ARRAY_SIZE;
}

总结

在JDK6下ArrayList list = new ArrayList();//底层创建了长度为10的Object[]数组elementData
- 默认情况下，扩容为原来的1.5倍+1，同时需要将原有的底层数组中的数据复制到新的数组中
在JDK7，8下
- ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}，并没有创建长度为10的数据
- list.add(123);//第一次调用add()时，底层才创建了长度为10的数组，并将数据123添加到elementData中
- 默认情况下，扩容为原来的1.5倍
小结：
- jdk6中的ArrayList的对象的创建类似于单例模式的饿汉式
- jdk7 8 中的ArrayList的对象的创建类似于单例模式的懒汉式，延迟了底层数组的创建，节省了空间。

Shacoray

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java基础-Java集合框架-Collection子接口-List接口以及ArrayList的源码分析

Java集合框架-Collection子接口之一-List接口List接口概述鉴于Java中数组用来存储数据的局限性，我们通常使用List替代数组List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素JDK API中List接口的实现类常用的有：ArrayList、LinkedList和Vector比较ArrayList、LinkedList、Vector的异同
复制链接

扫一扫