基于java1.8 ArrayList 源码分析

已于 2023-09-13 02:08:36 修改
阅读量183 收藏
点赞数 1
分类专栏： Java 文章标签： java
于 2021-06-15 18:05:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ww_kobe/article/details/117928204
版权

1、结构

  • ArrayList 继承 AbstractList 抽象类，该类是只支持按次序访问
  • ArrayList 实现了 List 接口
  • 实现了RandomAccess接口，表明ArrayList支持快速（通常是固定时间）随机访问
  • 实现了 Cloneable 接口，覆盖了 clone 方法，即可以被克隆
  • 实现了 Serializable 接口，支持序列化
public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

2、内部变量

// 默认容量为10
private static final int DEFAULT_CAPACITY = 10;

// 空对象数组
private static final Object[] EMPTY_ELEMENTDATA = {};

// 默认空对象数组，由空的构造参数生成
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

// ArrayList对象实际上就是一个容器数组
transient Object[] elementData; // non-private to simplify nested class access

// 实际元素大小
private int size;

// 最大容量
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

3、构造函数

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

/**
 * Constructs an empty list with the specified initial capacity.
 *
 * @param  initialCapacity  the initial capacity of the list
 * @throws IllegalArgumentException if the specified initial capacity is negative
 *
 * 指定容量大小的构造函数
 */
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 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;
    }
}

4、主要方法{get()、set()、add()、remove()、clear()、contains()}

4.1 get()

public E get(int index) {
    // 防止越界，索引不能大于数组长度
    rangeCheck(index);
    
    // 直接返回索引处的元素
    return elementData(index);
}

4.2 set()

/**
 * Replaces the element at the specified position in this list with the specified element.
 *
 * @param index index of the element to replace
 * @param element element to be stored at the specified position
 * @return the element previously at the specified position
 * @throws IndexOutOfBoundsException {@inheritDoc}
 *
 * 用指定的元素替换列表中指定位置的元素
 */
public E set(int index, E element) {
    rangeCheck(index);

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

4.3 add()

add（E e）

  1. ensureCapacityInternal（size+1）方法，在该方法中首先判断了当前数组是否是空数组，如果是则比较加入的个数与默认个数(10)比较，取较大值，否则调用2方法。
  2. ensureExplicitCapacity(int minCapacity)方法，在该方法中首先是对modCount+1，判断数组真实元素个数加1后的长度与当前数组长度大小关系，如果小于0，返回，如果大于0，则调用3方法。
  3. grow(minCapacity)方法，使用 oldCapacity + (oldCapacity >> 1)是当前数组的长度变为原来的1.5倍，再与扩容后的长度以及扩容的上限值进行对比，然后调用4方法。
  4. Arrays.copyOf(elementData, newCapacity)方法，该方法的底层就是调用System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength))方法，把旧数据的数据拷贝到扩容后的新数组里面，返回新数组，然后再把新添加的元素赋值给扩容后的size+1的位置里面。

add（int idnex,E element）

       主要的差异是增加了一行代码：System.arraycopy(elementData, index, elementData, index + 1, size - index)，从index位置开始以及之后的数据，整体拷贝到index+1开始的位置，然后再把新加入的数据放在index这个位置，而之前的数据不需要移动。（这些动作比较消耗性能）

/**
 * add()
 * 在list末尾追加一个元素
 */
public boolean add(E e) {
	// 容量检测以及扩容
   ensureCapacityInternal(size + 1);  // Increments modCount!!
   // 将新元素增加到末尾
   elementData[size++] = e;
   return true;
}

private void ensureCapacityInternal(int minCapacity) {
	// 如果数组容器为空，初始化容器的容量，默认为10
   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);
}

/**
 * 扩容：容量在当前的基础上 + 50%
 */	
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    // 通过位运算符扩容，容量在当前的基础上 + 50%
    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);
}

// 指定索引add                                
public void add(int index, E element) {
    // 确保该索引要合法即大于等于0并且小于等于数组长度
    rangeCheckForAdd(index);

    // 确保数组容量大于等于size+1
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 将index索引位置（包括）及之后的元素都向后挪动一位
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    // 将index索引处设置为新增元素
    elementData[index] = element;
    size++;
}

4.4 remove()

  1. rangeCheck(index) 进行越界检查
  2. modCount 记录修改次数（可以用来检测快速失败的一种标志。）
  3. 通过索引找到要删除的元素
  4. 计算要移动的位数
  5. 移动元素（其实是覆盖掉要删除的元素）
  6. 将–size上的位置赋值为null，让gc(垃圾回收机制)更快的回收它。
  7. 返回被删除的元素
/**
 * 根据索引移除对象
 */
public E remove(int index) {
    // 防止越界，索引不能大于数组长度
    rangeCheck(index);

    // 操作数+1
    modCount++;
    E oldValue = elementData(index);

    // 将index后的元素都向前挪动一位，原index的元素就删除了
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    // 数组长度减1
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
}

/**
 * remove 指定对象 Object o
 * 判断 o 是否为 null，为 null 则遍历移除集合中为 null 的对象
 * 不为 null 则移除指定对象
 */
public boolean remove(Object o) {
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
} 

/*
 * Private remove method that skips bounds checking and does not
 * return the value removed.
 */
private void fastRemove(int index) {
    modCount++;
    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
}

/**
 * 删除fromIndex到toIndex之间的全部元素，把toIndex以后的元素移动（size-toIndex）位，把左移后空 
 * 的元素置为null好让垃圾回收机制回收内存，最后把新数组的大小赋值给size
 *
 */
protected void removeRange(int fromIndex, int toIndex) {
    modCount++;
    int numMoved = size - toIndex;
    System.arraycopy(elementData, toIndex, elementData, fromIndex, numMoved);

    // clear to let GC do its work
    int newSize = size - (toIndex-fromIndex);
    for (int i = newSize; i < size; i++) {
        elementData[i] = null;
    }
    size = newSize;
}

public boolean removeAll(Collection<?> c) {
    //非空检查
    Objects.requireNonNull(c);
    //删除指定集合中的所有元素
    return batchRemove(c, false);
}

private boolean batchRemove(Collection<?> c, boolean complement) {
    final Object[] elementData = this.elementData;
    int r = 0, w = 0;
    boolean modified = false;
    try {
        for (; r < size; r++)
            if (c.contains(elementData[r]) == complement)
                elementData[w++] = elementData[r];
    } finally {
        // Preserve behavioral compatibility with AbstractCollection,
        // even if c.contains() throws.
        if (r != size) {
            System.arraycopy(elementData, r,
                             elementData, w,
                             size - r);
            w += size - r;
        }
        if (w != size) {
            // clear to let GC do its work
            for (int i = w; i < size; i++)
                elementData[i] = null;
            modCount += size - w;
            size = w;
            modified = true;
        }
    }
    return modified;
}

4.5 clear()

/**
 * Removes all of the elements from this list.  The list will
 * be empty after this call returns.
 */
public void clear() {
    modCount++;

    // clear to let GC do its work
    for (int i = 0; i < size; i++)
        elementData[i] = null;

    size = 0;
}

4.6 contains()

/**
 * Returns <tt>true</tt> if this list contains the specified element.
 * More formally, returns <tt>true</tt> if and only if this list contains
 * at least one element <tt>e</tt> such that
 * <tt>(o==null&nbsp;?&nbsp;e==null&nbsp;:&nbsp;o.equals(e))</tt>.
 *
 * @param o element whose presence in this list is to be tested
 * @return <tt>true</tt> if this list contains the specified element
 */
public boolean contains(Object o) {
    return indexOf(o) >= 0;
}

/**
 * Returns the index of the first occurrence of the specified element
 * in this list, or -1 if this list does not contain the element.
 * More formally, returns the lowest index <tt>i</tt> such that
 * <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,
 * or -1 if there is no such index.
 */
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.7 遍历

Iterator<String> it = arrayList.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
}

private class Itr implements Iterator<E> {
    int cursor;       // index of next element to return
    int lastRet = -1; // index of last element returned; -1 if no such
    int expectedModCount = modCount;

    public boolean hasNext() {
        return cursor != size;
    }

    @SuppressWarnings("unchecked")
    public E next() {
        checkForComodification();
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i + 1;
        return (E) elementData[lastRet = i];
    }

    public void remove() {
        if (lastRet < 0)
            throw new IllegalStateException();
        checkForComodification();

        try {
            ArrayList.this.remove(lastRet);
            cursor = lastRet;
            lastRet = -1;
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

    @Override
    @SuppressWarnings("unchecked")
    public void forEachRemaining(Consumer<? super E> consumer) {
        Objects.requireNonNull(consumer);
        final int size = ArrayList.this.size;
        int i = cursor;
        if (i >= size) {
            return;
        }
        final Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length) {
            throw new ConcurrentModificationException();
        }
        while (i != size && modCount == expectedModCount) {
            consumer.accept((E) elementData[i++]);
        }
        // update once at end of iteration to reduce heap write traffic
        cursor = i;
        lastRet = i - 1;
        checkForComodification();
    }

    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}

总结：

  1. arrayList可以存放null。
  2. arrayList本质上就是一个elementData数组。
  3. arrayList区别于数组的地方在于能够自动扩展大小，其中关键的方法就是gorw()方法。
  4. arrayList中removeAll(collection c)和clear()的区别就是removeAll可以删除批量指定的元素，而clear是全是删除集合中的元素。
  5. arrayList由于本质是数组，所以它在数据的查询方面会很快，而在插入删除这些方面，性能下降很多，有移动很多数据才能达到应有的效果。
  6. arrayList实现了RandomAccess，所以在遍历它的时候推荐使用for循环。
ww_kobe
关注
专栏目录
ArrayList源码解析（JDK1.8）-逐行代码分析
yphust的博客
08-19 628
文章目录类图内部参数构造方法ArrayList()ArrayList(int initialCapacity)ArrayList（Collection c）常用方法解析add(E e)ensureCapacityInternalensureExplicitCapacitygrowddAll(Collection<? extends E> c)addAll(int index, Collection<? extends E> c)get(int index)E elementData(
Java1.8 ArrayList ConcurrentModificationException源码分析
GD_2014的博客
03-25 752
序言 本文主要从JDK（1.7，1.8）源码角度分析ArrayList操作及ConcurrentModificationException异常产生的原因和解决方案 文章内容安排 JDK1.7 ArrayList操作**（补充中）** JDK1.7 ConcurrentModificationException**（补充中）** JDK1.8 ArrayList操作**（补充中）** JDK1.8...
ArrayList(JDK1.8)源码+底层数据结构分析
m0_49692893的博客
02-23 2370
ArrayList 的底层数据结构是一维数组，而且是动态数组。与 Java 中的数组相比，它的容量能动态增长。在添加大量元素前，应用程序可以使用 ensureCapacity 操作来增加 ArrayList实例的容量。这可以减少递增式再分配的数量。
Java之ArrayList源码解读（JDK 1.8）
anxpp的博客
04-20 8742
java.util.ArrayList     详细注释了ArrayList的实现，基于JDK 1.8 。     迭代器SubList部分未详细解释，会放到其他源码解读里面。此处重点关注ArrayList本身实现。 import java.util.AbstractList; import java.util.Arrays; import java.util.BitSet; impor
深入java集合类-ArrayList(jdk1.8)
littlewhitevg的博客
04-22 249
参考:https://www.cnblogs.com/LittleHann/p/3690187.html 文章目录1.集合类简介1.1 Set1.2 List1.3 Queue1.1.2 Map2.ArrayList相关深入2.1 ArrayList源码2.1.1 add()2.1.2 get()2.1.3 set()2.1.4 remove()2.1.5 SubList2.2 并发修改异常...
ArrayList 源码解析（JDK1.8）
流华追梦的专栏
10-19 192
ArrayList实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量(capacity)，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添加元素时，如果容量不足，容器会自动增大底层数组的大小。由于Java泛型只是编译器提供的语法糖，所以这里的数组是一个Object数组，以便能够容纳任何类型的对象。
【ArrayList】JDK1.8源码详细注释 以及如何实现线程安全的链表
最新发布
wdx7770的博客
08-10 839
逻辑上来说, 你迭代一次, 当然只能判断当前的对象是不是需要被删除, 干嘛要多次删除?其次, 这样也能让迭代器的代码逻辑更简洁, 避免很多边界条件的判断, 也能避免很多潜在的错误;如果是无参构造创建的ArrayList，首次添加第一个元素时，扩容到10，如果首次直接使用 addAll 添加集合c，会有特殊判断, 扩容到 max { c.length , 10 }原理是: 创建 COWIterator 的时候, 会将底层数组的引用传进入, 这样, 即使有其他线程更换了底层数组, 也不会影响到当前的迭代器;
Java 1.8 ArrayList 源码解析
"ArrayList在Jdk1.8中的源码分析" ArrayList是Java集合框架中一个重要的类，它实现了List接口，提供了动态数组的功能。ArrayList基于Java 1.8的源码，具有以下特点： 1. **容量与扩容**： ArrayList内部通过一个...
深入解析JDK1.8 ArrayList源码
"这篇分析基于JDK1.8的ArrayList源码，主要探讨ArrayList的核心特性，包括构造函数、成员变量、元素操作等。ArrayList作为Java中的动态数组，其内部使用一个Object类型的数组来存储元素，提供了高效查找但相对低效的...
ArrayList源码分析(含jdk1.8).pdf
04-24
在了解ArrayList的源码分析时，我们主要探讨其在Java Development Kit (JDK) 1.8中的实现。ArrayList是一个非常重要的集合框架，用于动态数组的实现，其功能类似于数组，但可以在运行时动态调整大小。它是一个非线程...
jdk 1.8源码包，包含sun源码，绝对真实，自己看大小就懂了，靠谱
05-08
jdk源码包的完整版本，可以查看sun的源码了，包括sun包下的反射，nio等等源码，现在统统不是问题。当我要找jdk源码包的时候，上面好多都是不全，或者假的，我也是醉了。
jdk1.8 全部源码，包括sun
07-12
jdk1.8全部源码，包括未公开部分sun源码，代码来自openJDK官网
JDK1.8源码
08-24
这是jdk1.8.0_181版本的jdk源码，可以直接使用IDEA或者eclipse导入，方便查看JDK源码
jdk1.8 源码包
03-23
jdk源码包，可以百度搜索eclipse添加方法，添加后 ctrl+鼠标左键点击方法名 可以查看源代码。
JDK1.8完整源码，包含sun等包，以及C/C++ native层代码
05-10
OpenJDK源码 1.8u131版本。
JDK1.8--ArrayList源码分析
qq_41370698的博客
04-22 982
一：基本介绍 ArrayList 是最常用的 List 实现类，内部是通过数组实现的，它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能有间隔，当数组大小不满足时需要增加存储能力，就要将已经有数组的数据复制到新的存储空间中。当从 ArrayList 的中间位置插入或者删除元素时，需要对数组进行复制、移动、代价比较高。因此，它适合随机查找和遍历，不适合插入和删除。 ArrayList继承于AbstractList类，实现了List接口；他是一个数组队列，提供了相关的添加、删除、遍历的功能。 Array
ArrayList源码分析（JDK1.8）
qq_25210753的博客
03-10 232
一、数据结构 ArrayList的数据结构是Object类型的数组，可以存放所有数据类型，我们对ArrayList的所有操作都是基于数组的 二、ArrayList源码分析 2.1 类的属性 public class ArrayList&lt;E&gt; extends AbstractList&lt;E&gt; implements List&lt;E&gt;, Ran...
Java源码--JDK 1.8 HashMap 重点源码部分剖析
Paranoid
04-20 919
注：感谢 美团点评技术团队 的分享~~，博客部分内容摘抄自其中。侵删！ 今天我们来探究一下 HashMap 的内部实现机制。 明确 JDK 1.8 中的 HashMap 使用数组 + 链表 + 红黑树的结构进行实现。 HashMap 的底层思想主要是哈希表，我们来看看 Java 的设计者们是怎么使用数组 + 链表 + 红黑树设计出 HashMap 的。 HashMap的基本...
ArrayList 源码分析（JDK1.8）
知性人 -- 的博客
06-14 281
ArrayList简介   ArrayList 是一个数组队列，相当于 动态数组。与Java中的数组相比，它的容量能动态增长。它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。   ArrayList 继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值