`

ArrayList实现原理

    博客分类:
  • Java
 
阅读更多

1. ArrayList概述:

   ArrayList是List接口的可变数组的实现。实现了所有可选列表操作,并允许包括 null 在内的所有元素。除了实现 List 接口外,此类还提供一些方法来操作内部用来存储列表的数组的大小。
   每个ArrayList实例都有一个容量,该容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向ArrayList中不断添加元 素,其容量也自动增长。自动增长会带来数据向新数组的重新拷贝,因此,如果可预知数据量的多少,可在构造ArrayList时指定其容量。在添加大量元素 前,应用程序也可以使用ensureCapacity操作来增加ArrayList实例的容量,这可以减少递增式再分配的数量。
   注意,此实现不是同步的。如果多个线程同时访问一个ArrayList实例,而其中至少一个线程从结构上修改了列表,那么它必须保持外部同步。

 

2. ArrayList的实现:

   对于ArrayList而言,它实现List接口、底层使用数组保存所有元素。其操作基本上是对数组的操作。下面我们来分析ArrayList的源代码:

   1) 底层使用数组实现:

Java代码  收藏代码
  1. private transient Object[] elementData;  

    2) 构造方法:
   ArrayList提供了三种方式的构造器,可以构造一个默认初始容量为10的空列表、构造一个指定初始容量的空列表以及构造一个包含指定collection的元素的列表,这些元素按照该collection的迭代器返回它们的顺序排列的。

Java代码  收藏代码
  1. public ArrayList() {  
  2.     this(10);  
  3. }  
  4.   
  5. public ArrayList(int initialCapacity) {  
  6.     super();  
  7.     if (initialCapacity < 0)  
  8.         throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);  
  9.     this.elementData = new Object[initialCapacity];  
  10. }  
  11.   
  12. public ArrayList(Collection<? extends E> c) {  
  13.     elementData = c.toArray();  
  14.     size = elementData.length;  
  15.     // c.toArray might (incorrectly) not return Object[] (see 6260652)  
  16.     if (elementData.getClass() != Object[].class)  
  17.         elementData = Arrays.copyOf(elementData, size, Object[].class);  
  18. }  

    3) 存储:
   ArrayList提供了set(int index, E element)、add(E e)、add(int index, E element)、addAll(Collection<? extends E> c)、addAll(int index, Collection<? extends E> c)这些添加元素的方法。下面我们一一讲解:

Java代码  收藏代码
  1. // 用指定的元素替代此列表中指定位置上的元素,并返回以前位于该位置上的元素。  
  2. public E set(int index, E element) {  
  3.     RangeCheck(index);  
  4.   
  5.     E oldValue = (E) elementData[index];  
  6.     elementData[index] = element;  
  7.     return oldValue;  
  8. }  
Java代码  收藏代码
  1. // 将指定的元素添加到此列表的尾部。  
  2. public boolean add(E e) {  
  3.     ensureCapacity(size + 1);   
  4.     elementData[size++] = e;  
  5.     return true;  
  6. }  
Java代码  收藏代码
  1. // 将指定的元素插入此列表中的指定位置。  
  2. // 如果当前位置有元素,则向右移动当前位于该位置的元素以及所有后续元素(将其索引加1)。  
  3. public void add(int index, E element) {  
  4.     if (index > size || index < 0)  
  5.         throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);  
  6.     // 如果数组长度不足,将进行扩容。  
  7.     ensureCapacity(size+1);  // Increments modCount!!  
  8.     // 将 elementData中从Index位置开始、长度为size-index的元素,  
  9.     // 拷贝到从下标为index+1位置开始的新的elementData数组中。  
  10.     // 即将当前位于该位置的元素以及所有后续元素右移一个位置。  
  11.     System.arraycopy(elementData, index, elementData, index + 1, size - index);  
  12.     elementData[index] = element;  
  13.     size++;  
  14. }  
Java代码  收藏代码
  1. // 按照指定collection的迭代器所返回的元素顺序,将该collection中的所有元素添加到此列表的尾部。  
  2. public boolean addAll(Collection<? extends E> c) {  
  3.     Object[] a = c.toArray();  
  4.     int numNew = a.length;  
  5.     ensureCapacity(size + numNew);  // Increments modCount  
  6.     System.arraycopy(a, 0, elementData, size, numNew);  
  7.     size += numNew;  
  8.     return numNew != 0;  
  9. }  
Java代码  收藏代码
  1. // 从指定的位置开始,将指定collection中的所有元素插入到此列表中。  
  2. public boolean addAll(int index, Collection<? extends E> c) {  
  3.     if (index > size || index < 0)  
  4.         throw new IndexOutOfBoundsException(  
  5.             "Index: " + index + ", Size: " + size);  
  6.   
  7.     Object[] a = c.toArray();  
  8.     int numNew = a.length;  
  9.     ensureCapacity(size + numNew);  // Increments modCount  
  10.   
  11.     int numMoved = size - index;  
  12.     if (numMoved > 0)  
  13.         System.arraycopy(elementData, index, elementData, index + numNew, numMoved);  
  14.   
  15.     System.arraycopy(a, 0, elementData, index, numNew);  
  16.     size += numNew;  
  17.     return numNew != 0;  
  18. }  

    4) 读取:

Java代码  收藏代码
  1. // 返回此列表中指定位置上的元素。  
  2. public E get(int index) {  
  3.     RangeCheck(index);  
  4.   
  5.     return (E) elementData[index];  
  6. }  

    5) 删除:
   ArrayList提供了根据下标或者指定对象两种方式的删除功能。如下:

Java代码  收藏代码
  1. // 移除此列表中指定位置上的元素。  
  2. public E remove(int index) {  
  3.     RangeCheck(index);  
  4.   
  5.     modCount++;  
  6.     E oldValue = (E) elementData[index];  
  7.   
  8.     int numMoved = size - index - 1;  
  9.     if (numMoved > 0)  
  10.         System.arraycopy(elementData, index+1, elementData, index, numMoved);  
  11.     elementData[--size] = null// Let gc do its work  
  12.   
  13.     return oldValue;  
  14. }  
Java代码  收藏代码
  1. // 移除此列表中首次出现的指定元素(如果存在)。这是应为ArrayList中允许存放重复的元素。  
  2. public boolean remove(Object o) {  
  3.     // 由于ArrayList中允许存放null,因此下面通过两种情况来分别处理。  
  4.     if (o == null) {  
  5.         for (int index = 0; index < size; index++)  
  6.             if (elementData[index] == null) {  
  7.                 // 类似remove(int index),移除列表中指定位置上的元素。  
  8.                 fastRemove(index);  
  9.                 return true;  
  10.             }  
  11. else {  
  12.     for (int index = 0; index < size; index++)  
  13.         if (o.equals(elementData[index])) {  
  14.             fastRemove(index);  
  15.             return true;  
  16.         }  
  17.     }  
  18.     return false;  
  19. }  

    注意:从数组中移除元素的操作,也会导致被移除的元素以后的所有元素的向左移动一个位置。
   6) 调整数组容量:
   从上面介绍的向ArrayList中存储元素的代码中,我们看到,每当向数组中添加元素时,都要去检查添加后元素的个数是否会超出当前数组的长度,如果超 出,数组将会进行扩容,以满足添加数据的需求。数组扩容通过一个公开的方法ensureCapacity(int minCapacity)来实现。在实际添加大量元素前,我也可以使用ensureCapacity来手动增加ArrayList实例的容量,以减少递增 式再分配的数量。

Java代码  收藏代码
  1. public void ensureCapacity(int minCapacity) {  
  2.     modCount++;  
  3.     int oldCapacity = elementData.length;  
  4.     if (minCapacity > oldCapacity) {  
  5.         Object oldData[] = elementData;  
  6.         int newCapacity = (oldCapacity * 3)/2 + 1;  
  7.             if (newCapacity < minCapacity)  
  8.                 newCapacity = minCapacity;  
  9.       // minCapacity is usually close to size, so this is a win:  
  10.       elementData = Arrays.copyOf(elementData, newCapacity);  
  11.     }  
  12. }  

   从上述代码中可以看出,数组进行扩容时,会将老数组中的元素重新拷贝一份到新的数组中,每次数组容量的增长大约是其原容量的1.5倍。这种操作的代价是很 高的,因此在实际使用时,我们应该尽量避免数组容量的扩张。当我们可预知要保存的元素的多少时,要在构造ArrayList实例时,就指定其容量,以避免 数组扩容的发生。或者根据实际需求,通过调用ensureCapacity方法来手动增加ArrayList实例的容量。
   ArrayList还给我们提供了将底层数组的容量调整为当前列表保存的实际元素的大小的功能。它可以通过trimToSize方法来实现。代码如下:

Java代码  收藏代码
  1. public void trimToSize() {  
  2.     modCount++;  
  3.     int oldCapacity = elementData.length;  
  4.     if (size < oldCapacity) {  
  5.         elementData = Arrays.copyOf(elementData, size);  
  6.     }  
  7. }  

   7) Fail-Fast机制:
ArrayList也采用了快速失败的机制,通过记录modCount参数来实现。在面对并发的修改时,迭代器很快就会完全失败,而不是冒着在将来某个不确定时间发生任意不确定行为的风险。具体介绍请参考我之前的文章深入Java集合学习系列:HashMap的实现原理 中的Fail-Fast机制。
   8) 关于其他 的一些方法的实现都很简单易懂,读者可参照API文档和源代码,一看便知,这里就不再多说。


3. 相关阅读:
   本系列的文章之前还整理了以下几篇,有兴趣的可以参考,望与大家分享心得,共同进步:
   1) 深入Java集合学习系列:HashMap的实现原理
   2) 深入Java集合学习系列:LinkedHashMap的实现原理
   3) 深入Java集合学习系列:HashSet的实现原理
   4) 深入Java集合学习系列:LinkedHashSet的实现原理

分享到:
评论

相关推荐

    深入Java集合学习系列(三):ArrayList实现原理

    本篇文档将深入探讨ArrayList的内部实现原理。 首先,ArrayList是Java集合框架中List接口的一个非常重要的实现。它允许包含重复的元素,也允许插入null值,这是区别于Java集合中的另一个List接口实现类LinkedList的...

    ArrayList的实现原理

    下面是ArrayList的实现原理及其关键操作的详细说明。 1. **ArrayList概述** - **容量**:ArrayList实例有一个容量,即用于存储列表元素的数组的大小。当添加元素导致容量不足时,ArrayList会自动扩大数组容量。 -...

    尚硅谷-深入Java集合3:ArrayList实现原理.pdf

    本教程特点: 1.更适合零基础学员: ·自Java语言起源始,循序渐进,知识点剖析细致且每章配备大量随堂练习,让你步步为营,学得透彻、练得明白 ·拒绝晦涩难懂的呆板教学,宋老师语言生动幽默,举例形象生动深入浅...

    Java进阶--深入理解ArrayList实现原理

    ArrayList是Java集合框架中常用的列表实现之一,它作为动态数组,允许...总的来说,深入理解ArrayList的实现原理有助于优化代码性能,特别是在处理大量数据时选择合适的集合类,以及在多线程环境中正确使用ArrayList。

    深入Java集合学习系列:ArrayList的实现原理

    《深入Java集合学习系列:ArrayList的实现原理》 在Java编程中,ArrayList是集合框架中一个重要的类,属于List接口的实现,它提供了动态数组的功能,允许我们在集合中存储、添加、删除元素,并且可以按索引访问。这...

    源码解析jdk7.0集合:ArrayList的底层实现原理.pdf

    在探讨 JDK 7.0 中 ArrayList 的底层实现原理之前,首先需要了解 ArrayList 作为 Java 集合框架中 List 接口的动态数组实现类的基本概念。ArrayList 提供了一种存储有序、可重复、允许为 null 的数据结构,并且该...

    模拟arraylist底层实现

    通过模拟ArrayList的底层实现,我们可以更好地理解ArrayList的工作原理和实现机制,从而提高自己的编程能力和技术水平。同时,我们也可以根据需要,自定义集合实现类以满足不同的需求和应用场景。

    java集合PDF汇总

    "深入Java集合学习系列(三):ArrayList实现原理_尚硅谷_张晓飞.pdf"可能是重复的,但再次强调ArrayList的实现原理:ArrayList的线程安全性较差,如果在并发环境下操作,需要配合synchronized关键字或者使用并发集合...

    我的ArrayList实现

    《我的ArrayList实现》这篇博客主要探讨了如何在Java中自定义一个类似ArrayList的数据结构,并深入理解ArrayList的工作原理。ArrayList是Java集合框架中的一个重要组件,它是一个动态数组,提供了高效的元素添加、...

    深入Java集合学习系列

    在"深入Java集合学习系列(二):ArrayList实现原理_尚硅谷_张晓飞.pdf"中,你可以了解到ArrayList的内部结构、扩容机制以及其在不同操作下的性能特点。 其次,HashMap是Java中处理键值对的数据结构,它实现了Map接口...

    Java ArrayList实现的快排,归并排序,堆排序

    本篇将重点讲解如何利用ArrayList实现快速排序(Quick Sort)、归并排序(Merge Sort)和堆排序(Heap Sort)这三种经典的排序算法,并探讨它们的原理、优缺点以及在实际应用中的选择。 **快速排序(Quick Sort)**...

    arrayList原理说明

    ### ArrayList原理详解 #### 概述 `ArrayList`是Java集合框架中的一种动态数组实现,它继承自`AbstractList`并实现了`List`接口。与普通的数组不同的是,`ArrayList`可以根据实际需要自动调整其存储空间大小。这种...

    ArrayList底层原理

    ArrayList是Java编程语言中常用的集合类之一,它实现了List接口,并且其底层数据结构基于数组。ArrayList的主要特点是允许用户按索引访问元素,且提供了动态扩容的能力。在深入理解ArrayList的底层原理之前,我们先...

    java软件技术文档-深入java8的集合1:ArrayList的实现原理

    ArrayList 在 Java 中是基于动态数组实现的,它实现了 List 接口并支持所有可选的列表操作。ArrayList 允许 null 元素,其内部通过一个 Object 数组存储元素,通过 get、add、remove 等方法提供对元素的操作。当需要...

    ArrayList集合底层原理.pdf

    ### ArrayList集合底层原理 ...以上总结了ArrayList集合的底层原理,包括其基本概念、底层实现、构造方法、属性、扩容机制以及在分布式环境下的考量点。掌握这些知识点对于编写高效且稳定的Java应用程序至关重要。

    ArrayList的底层原理Java系列2021.pdf

    本文将深入分析ArrayList的底层原理,包括其数据结构、线程安全性问题以及实现方式。 一、ArrayList的数据结构 ArrayList内部是基于数组的数据结构进行设计的,这个数组可以存储任意类型的对象,因为它内部使用的...

    对ArrayList和LinkedList底层实现原理详解

    ArrayList和LinkedList底层实现原理详解 ArrayList 底层实现方式的知识点: 1. ArrayList 底层实现方式:ArrayList 通过数组实现,一旦我们实例化 ArrayList 无参数构造函数默认为数组初始化长度为 10。 2. add ...

Global site tag (gtag.js) - Google Analytics