ArrayList集合(一)--源码

最新推荐文章于 2024-06-23 22:43:28 发布
最新推荐文章于 2024-06-23 22:43:28 发布
阅读量283 收藏
点赞数
文章标签： arraylist
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yudiandemingzi/article/details/78723775
版权
ArrayList源码

      一、定义

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

从中我们可以了解到：

  • ArrayList<E>：说明ArrayList支持泛型。
  • extends AbstractList<E> ：继承了AbstractList。AbstractList提供List接口的骨干实现，以最大限度地减少“随机访问”数据存储（如ArrayList）实现Llist所需的工作。
  • implements List<E>：实现了List。实现了所有可选列表操作。
  • implements RandomAccess：表明ArrayList支持快速（通常是固定时间）随机访问。此接口的主要目的是允许一般的算法更改其行为，从而在将其应用到随机或连续访问列表时能提供良好的性能。
  • implements Cloneable：表明其可以调用clone()方法来返回实例的field-for-field拷贝。
  • implements java.io.Serializable：表明该类具有序列化功能。
    二、构造函数 
/ 默认构造函数
ArrayList()

// capacity是ArrayList的默认容量大小。当由于增加数据导致容量不足时，容量会添加上一次容量大小的一半。
ArrayList(int capacity)

// 创建一个包含collection的ArrayList
ArrayList(Collection<? extends E> collection)
  三、ArrayList源码解析 
import java.util.*;  
   
 public class ArrayList<E> extends AbstractList<E>  
         implements List<E>, RandomAccess, Cloneable, java.io.Serializable  
 {  
     // 序列版本号  
     private static final long serialVersionUID = 8683452581122892189L;  
   
     // 保存ArrayList中数据的数组  
     private transient Object[] elementData;  
   
     // ArrayList中实际数据的数量  
     private int size;  
   
     // ArrayList带容量大小的构造函数。  
     public ArrayList(int initialCapacity) {  
         super();  
         if (initialCapacity < 0)  
             throw new IllegalArgumentException("Illegal Capacity: "+  
                                                initialCapacity);  
         // 新建一个数组  
         this.elementData = new Object[initialCapacity];  
     }  
   
        // ArrayList构造函数。默认容量是10。  
     public ArrayList() {  
         this(10);  
     }  
   
        // 创建一个包含collection的ArrayList  
     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);  
     }  
       
        // 添加元素e  
     public boolean add(E e) {  
        // 确定ArrayList的容量大小  
         ensureCapacity(size + 1);  // Increments modCount!!  
        // 添加e到ArrayList中  
         elementData[size++] = e;  
         return true;  
     }  
   
       // 确定ArrarList的容量。  
       // 若ArrayList的容量不足以容纳当前的全部元素，设置 新的容量=“(原始容量x3)/2 + 1”  
     public void ensureCapacity(int minCapacity) {  
       // 将“修改统计数”+1  
         modCount++;  
         int oldCapacity = elementData.length;  
       // 若当前容量不足以容纳当前的元素个数，设置 新的容量=“(原始容量x3)/2 + 1”  
         if (minCapacity > oldCapacity) {  
             Object oldData[] = elementData;  
             int newCapacity = (oldCapacity * 3)/2 + 1;  
             if (newCapacity < minCapacity)  
                 newCapacity = minCapacity;  
             elementData = Arrays.copyOf(elementData, newCapacity);  
         }  
     }  
       
       // 返回ArrayList的实际大小  
     public int size() {  
         return size;  
     }  
   
      // 返回ArrayList是否包含Object(o)  
     public boolean contains(Object o) {  
         return indexOf(o) >= 0;  
     }  
        
      // 正向查找，返回元素的索引值  
     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;  
         }  
   
      // 返回ArrayList是否为空  
     public boolean isEmpty() {  
         return size == 0;  
     }  
          
   
      // 返回ArrayList的Object数组  
     public Object[] toArray() {  
         return Arrays.copyOf(elementData, size);  
     }  
   
      // 返回ArrayList的模板数组。所谓模板数组，即可以将T设为任意的数据类型  
     public <T> T[] toArray(T[] a) {  
         // 若数组a的大小 < ArrayList的元素个数；  
         // 则新建一个T[]数组，数组大小是“ArrayList的元素个数”，并将“ArrayList”全部拷贝到新数组中  
         if (a.length < size)  
             return (T[]) Arrays.copyOf(elementData, size, a.getClass());  
   
         // 若数组a的大小 >= ArrayList的元素个数；  
         // 则将ArrayList的全部元素都拷贝到数组a中。  
         System.arraycopy(elementData, 0, a, 0, size);  
         if (a.length > size)  
             a[size] = null;  
         return a;  
     }  
   
      // 获取index位置的元素值  
     public E get(int index) {  
      //判断数组是否越界  
         RangeCheck(index);  
   
         return (E) elementData[index];  
     }  
   
      // 将e添加到ArrayList的指定位置  
     public void add(int index, E element) {  
         if (index > size || index < 0)  
             throw new IndexOutOfBoundsException(  
             "Index: "+index+", Size: "+size);  
   
         ensureCapacity(size+1);  // Increments modCount!!  
         System.arraycopy(elementData, index, elementData, index + 1,  
              size - index);  
         elementData[index] = element;  
         size++;  
     }  
   
      // 删除ArrayList指定位置的元素  
     public E remove(int index) {  
         RangeCheck(index);  
   
         modCount++;  
         E oldValue = (E) elementData[index];  
   
         int numMoved = size - index - 1;  
         if (numMoved > 0)  
             System.arraycopy(elementData, index+1, elementData, index,  
                  numMoved);  
         elementData[--size] = null; // Let gc do its work  
   
         return oldValue;  
     }  
   
       // 删除ArrayList的指定元素  
     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;  
     }  
   
       // 清空ArrayList，将全部的元素设为null  
     public void clear() {  
         modCount++;  
   
         for (int i = 0; i < size; i++)  
             elementData[i] = null;  
   
         size = 0;  
     }  
      
       // 将ArrayList的“容量，所有的元素值”都写入到输出流中  
     private void writeObject(java.io.ObjectOutputStream s)  
         throws java.io.IOException{  
       // Write out element count, and any hidden stuff  
     int expectedModCount = modCount;  
     s.defaultWriteObject();  
   
         // 写入“数组的容量”  
         s.writeInt(elementData.length);  
   
       // 写入“数组的每一个元素”  
     for (int i=0; i<size; i++)  
             s.writeObject(elementData[i]);  
   
     if (modCount != expectedModCount) {  
             throw new ConcurrentModificationException();  
         }  
     }  
       
       // java.io.Serializable的读取函数：根据写入方式读出  
       // 先将ArrayList的“容量”读出，然后将“所有的元素值”读出  
     private void readObject(java.io.ObjectInputStream s)  
         throws java.io.IOException, ClassNotFoundException {  
         // Read in size, and any hidden stuff  
         s.defaultReadObject();  
   
         // 从输入流中读取ArrayList的“容量”  
         int arrayLength = s.readInt();  
         Object[] a = elementData = new Object[arrayLength];  
   
         // 从输入流中将“所有的元素值”读出  
         for (int i=0; i<size; i++)  
             a[i] = s.readObject();  
     }  
 }


  总结：
(01) ArrayList 实际上是通过一个数组去保存数据的。当我们构造ArrayList时；若使用默认构造函数，则ArrayList的默认容量大小是10。
(02) 当ArrayList容量不足以容纳全部元素时，ArrayList会重新设置容量：新的容量=“(原始容量x3)/2 + 1”。
(03) ArrayList的克隆函数，即是将全部元素克隆到一个数组中。
(04) ArrayList实现java.io.Serializable的方式。当写入到输出流时，先写入“容量”，再依次写入“每一个元素”；当读出输入流时，先读取“容量”，再依次读取“每一个元素”。

   参考：
 
    水滴石穿，成功的速度一定要超过父母老去的速度！ 少尉【3】

后端元宇宙
关注
集合之ArrayList源码学习
juemuren123的博客
08-15 96
集合之ArrayList源码学习 ArrayList是日常开发经常用到的数据结构，底层是用数组实现的List，相当于单纯的数组相比，ArrayList有动态扩容的能力并提供了很多动态数组的方法。 继承关系 ArrayList继承了AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable等接口。 ArrayList实现了List，提供了基础的添加、删除、查找、遍历等操作。 ArrayList实现了RandomAccess，提供了随
集合-ArrayList源码分析
java_cG的博客
08-06 607
ArrayList分析继承关系:底层数据结构:特点:源码分析:构造方法:添加方法:删除操作:覆盖操作:获取方法清除操作:包含操作:是否为空: ArrayList是Java集合框架中较为常用的一种数据结构.下面从不同层面来介绍它. 继承关系: ArrayList继承了AbstractList,实现了List,RandomAccess(随机访问),Cloneable,Serializable接口 public class ArrayList<E> extends AbstractList<E&
ArrayList源码
07-22
反编译系统的，只是做个例子。 为了凑够20个字，我多打几个字……
ArrayList 源码
ironmanoOOoo的博客
07-22 1721
集合类中，最基础也是最常用的，大概就是ArrayList了吧。ArrayList的本质，是一个可变长的数组。那有人可能就会问，哎呀这个数组老简单了，有什么好看的啊……但事实上，在面试时，有些人还是对源码的细节说不清楚，从而留下较差的印象。这里，我就带着大家，一点一点地梳理一下，ArrayList的底层源码吧。概览..ArrayList类继承自AbstractList类，且实现了List、RandomAccess、Cloneable和Serializable接口。...
ArrayList源码详解篇
最新发布
2401_85112041的博客
06-23 742
System.out.println(asList.getClass());Object[] asListArray = asList.toArray();// class [Ljava.lang.String;System.out.println(asListArray.getClass());// java.lang.ArrayStoreExceptionasListArray[0] = new Object();}我们通过这个例子可以看出来，方法会返回Object[]没有问题。而的私有内部类Array
ArrayList的源码
02-18
源码分析见我博文：http://blog.csdn.net/wabiaozia/article/details/50684556
ArrayList-LinkedList-源码.rar
10-10
在Java编程中，ArrayList和LinkedList是两种常见的动态数组，它们都是Java集合框架的一部分，提供了对元素存储和操作的功能。本篇将深入探讨ArrayList和LinkedList的内部实现机制，通过源码分析来揭示它们在性能、...
Java集合框架ArrayList源码分析（一）
09-01
《深入剖析Java集合框架ArrayList源码》 Java集合框架中的ArrayList是开发者常用的数据结构，它是一种基于动态数组实现的列表。ArrayList的特点在于它的内部结构、性能优化以及在并发环境下的处理方式。本文将深入...
javaarraylist源码-MP3-Player-Project-for-Data-Structures-Course:该项目由一个功能性
05-19
这个"javaarraylist源码-MP3-Player-Project-for-Data-Structures-Course"项目显然是一个教学示例，用于数据结构课程，通过构建一个MP3播放器来演示ArrayList的使用。下面将详细探讨ArrayList的基本概念、工作原理...
java集合源码-javaSE-:集合源码剖析
05-19
在"java集合源码-javaSE-:集合源码剖析"这个主题中，我们将深入探讨Java集合框架的内部实现，包括ArrayList、LinkedList、HashMap、HashSet等常见集合类的源码分析。 1. **ArrayList**: ArrayList是基于动态数组...
java集合源码-jdk-collection:java集合类源码阅读
05-19
集合源码 JDK-Collection集合入门 总的list和set类结构大致如下所示 Map不继承Collection,其结构如下 首先介绍下迭代器的概念 迭代器无非是一个接口,假设我们有一个数组,如果我们要实现迭代器,只需要根据该接口定义...
ArrayList 源码详解
坚持不懈
04-22 1083
ArrayList 继承自AbstractList，实现了List、Cloneable、RandomAccess(随机访问，通常是常数时间)、Serializable共四个接口。其底层实现是数组，所以对数组下标的访问的速度是很快的。 源码解析 /** *继承自AbstractList，实现了List、Cloneable、 *RandomAccess(随机访问，通常是常数时间)、S
ArrayList源码详解
ENFJ-A
08-16 402
1. 类图 2. 基本属性 /** * 默认容量 10 */ private static final int DEFAULT_CAPACITY = 10; /** * 用于空实例的共享空数组实例。 */ private static final Object[] EMPTY_ELEMENTDATA = {}; /** * * 默认容量（10）的空数组,添加第一个元素时，这个数组的容量会扩展为10。
ArrayList集合及常用方法的使用
qq_34419418的博客
10-28 2306
ArrayLise<E> 集合 解读 1.1 ArrayList就是动态数组 数组长度可以发生变化 1.2 <E> 表示泛型 1.3 泛型：也就是装在集合当中的所有元素全部都是统一的类型 ArrayList<E>集合的优点 2.1 集合：长度可以发生变化 2.2 数组：一旦创建数组长度不可以发生变化 注意事项 3.1 ArrayList 集合来说打印的是地址值 而非内容 而基本数据类型无法使用 只有用引用数据类型 3.2 如果ArrayList集合是空 得到的
ArrayList 源码解析
weixin_50837529的博客
08-05 214
首先因为调用了 add 方法，因此的话就将 modCount++ 变为 1，这个 modCount 是继承自 abstractList 的属性，然后在这个函数内存继续调用 add() 的重载方法，传入三个参数，一个是当前添加的元素的值，一个是当前的 Array List 中存数据的缓冲区，一个是当前容器的容量。容量是用于存储列表中的元素的数组的大小。这段话的意思是，ArrayList 实现了 List 接口，是一个可以调整的数组，可以存储任意类型的数据，包括 null 值，和操作数组的时间复杂度类似（...
深度解析Java ArrayList源码
ArrayList在Java编程中是一个常用的集合类，它实现了List接口，提供了可调整大小的数组实现。ArrayList的主要特点是可以动态地改变容量以适应元素数量的变化。以下是对ArrayList源码中关键部分的分析： 1. **数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值