初步认识ArrayList源码

最新推荐文章于 2024-02-01 14:49:54 发布
最新推荐文章于 2024-02-01 14:49:54 发布
阅读量77 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33850624/article/details/109162659
版权

ArrayList源码解析

前言

自学编程时间不短了可是，中间放弃了很多次，一直看不懂源码，现在打算重新拾起来，学习源码。

Collections继承实现体系图

单列集合继承体系

ArrayList功能介绍

ArrayList是一个数组队列，相当于动态数组。底层实现是用数组实现的，可以自动扩容，可以存储所有元素，并且值可以为null

  1. 继承体系

java.lang.Object
java.util.AbstractCollection
java.util.AbstractList
java.util.ArrayList

  1. 实现接口

Serializable 序列化接口
Cloneable 覆盖了Object 中的 clone()方法可以被克隆
Iterable 迭代器接口，可以用迭代器进行迭代
Collection 集合的根接口
List 存放list集合的通用操作方法
RandomAccess 提供快速随机访问的接口

  1. 已知直接子类：

AttributeList
RoleList
RoleUnresolvedList

API - JDK8文档

//将指定的元素追加到此列表的末尾。 
boolean add(E e) 

//在此列表中的指定位置插入指定的元素。  
void add(int index, E element) 

//按指定集合的Iterator返回的顺序将指定集合中的所有元素追加到此列表的末尾。  
boolean addAll(Collection<? extends E> c) 

//将指定集合中的所有元素插入到此列表中，从指定的位置开始。  
boolean addAll(int index, Collection<? extends E> c) 

//从列表中删除所有元素。
void clear() 
  
//返回此 ArrayList实例的浅拷贝。  
Object clone() 

//如果此列表包含指定的元素，则返回 true 。
boolean contains(Object o) 
  
  
//如果需要，增加此 ArrayList实例的容量，
//以确保它可以至少保存最小容量参数指定的元素数。  
void ensureCapacity(int minCapacity) 

//对 Iterable的每个元素执行给定的操作，直到所有元素都被处理或动作引发异常。  
void forEach(Consumer<? super E> action) 

//返回此列表中指定位置的元素。 
E get(int index) 

//返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。   
int indexOf(Object o) 

//如果此列表不包含元素，则返回 true 。 
boolean isEmpty() 

//以正确的顺序返回该列表中的元素的迭代器。 
Iterator<E> iterator() 
  
//返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
int lastIndexOf(Object o) 

 //返回列表中的列表迭代器（按适当的顺序）。 
ListIterator<E> listIterator() 
  
//从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。  
ListIterator<E> listIterator(int index) 

//删除该列表中指定位置的元素。  
E remove(int index) 

//从列表中删除指定元素的第一个出现（如果存在）。  
boolean remove(Object o) 

//从此列表中删除指定集合中包含的所有元素。  
boolean removeAll(Collection<?> c) 

//删除满足给定谓词的此集合的所有元素。 
boolean removeIf(Predicate<? super E> filter) 

//从这个列表中删除所有索引在 fromIndex （含）和 toIndex之间的元素。  
protected void removeRange(int fromIndex, int toIndex) 

//将该列表的每个元素替换为将该运算符应用于该元素的结果。  
void replaceAll(UnaryOperator<E> operator) 
 
//仅保留此列表中包含在指定集合中的元素。
boolean retainAll(Collection<?> c) 
 
//用指定的元素替换此列表中指定位置的元素。 
E set(int index, E element) 
  
//返回此列表中的元素数。
int size() 
  
//使用提供的 Comparator对此列表进行排序以比较元素。  
void sort(Comparator<? super E> c) 

//在此列表中的元素上创建late-binding和故障快速 Spliterator 。  
Spliterator<E> spliterator() 

//返回此列表中指定的 fromIndex （包括）和 toIndex之间的独占视图。
List<E> subList(int fromIndex, int toIndex) 

//以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。   
Object[] toArray() 
 
//以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）; 
//返回的数组的运行时类型是指定数组的运行时类型。  
<T> T[] toArray(T[] a) 

//修改这个 ArrayList实例的容量是列表的当前大小。
void trimToSize()

源码解析

由于方法过多所以我只查看最核心的代码

变量定义

	/**
	*  初始定义的变量
	*
	*/
	// 序列化
    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 = {};

   //  Object对象元素数组，可以存放所有数据
    transient Object[] elementData; // non-private to simplify nested class access

  	//  记录集合里实际元素的个数
    private int size;
    
	//定义最大的的数组容量 为2147483647 -8 =2147483639
	private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

构造方法


   /**
     * 空参构造方法其为  默认的数组对象为，数组为空
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

 	/**
     * 有参构造1 根据传递进来的 种子 创建指定容量的集合 
     */
 	public ArrayList(int initialCapacity) {
 		// 如果传入的容量initialCapacity 大于0 直接将Object数组容量设置为initialCapacity
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
        	// 如果传入的是0  则将Object对象数组设置为默认 空数组 EMPTY_ELEMENTDATA
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
        	// 输入小于0 的数 抛出 异常 IllegalArgumentException
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

 

  	/**
  	*有参构造2 传入集合将其转换成ArrayList
  	*/
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray(); // 将传进来的集合转成数组赋值给 elementData 
        
        if ((size = elementData.length) != 0) {  // size 代表数组中的元素个数并且不为0
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            // 判断传入进来的集合是否是Object[]的类型
            if (elementData.getClass() != Object[].class) 
            	// 进行数组拷贝
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // 如果传进来的集合长度为0则替换成空数组.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

常用方法

add(E e)方法

	 /**
     *  添加新元素进入集合
     */
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // 确保数组有足够的空间添加元素
        
        //添加元素到数组当中 并将数组实际值+1
        elementData[size++] = e;
        return true; // 返回true代表添加成功
    }
    
    /**
    *
    * 上面的第一句代码调用了此方法
    */
	 private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
    
    // 上一个方法括号中的 alculateCapacity(elementData, minCapacity) 
     private static int calculateCapacity(Object[] elementData, int minCapacity) {
     // 判断一下数组的内容是否为空
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        	// 为空的话 返回 数组初始值和 传入的minCapacity 的较大值
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        
        return minCapacity;  // 直接返回 传递的值
    }

    private void ensureExplicitCapacity(int minCapacity) {
         // 上一层接口的 变量 记录了集合被修改的次数
        modCount++;

        // 如果 传递过来的minCapacity 大于数组的长度调用 grow（）方法扩充数组
        if (minCapacity - elementData.length > 0)
        	// 真实的扩容方法
            grow(minCapacity);  
    }

	 // 扩容方法
 	 private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;  // 获取旧的 数组容量
        // 旧容量扩大1.5倍赋值给newCapacity
        int newCapacity = oldCapacity + (oldCapacity >> 1); 
        
        //  如果 新的容量小于传递过来的容量，则将传递来的容量赋值给newCapacity
        if (newCapacity - minCapacity < 0) 
            newCapacity = minCapacity;
            
          //  如果 新的容量大于传递过来的容量， 则将 minCapacity 调用hugeCapacity（）判断参数是否合法在 范围内
        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();
        // 判断其容量和 最大值容量的关系，如果大于返回 Integer的最大值， 不等于返回MAX_ARRAY_SIZE 2147483639
        // 2147483647 -8 =2147483639
        return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
    }

add(int index,E e)方法 指定位置添加元素

	// 指定位置添加元素
    public void add(int index, E element) {
    
    	// 判断索引是否存在与数组当中
        rangeCheckForAdd(index);
        
		// 确保数组有足够的空间添加元素
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        
        // 使用系统的arraycopy方法 对数组扩容，并且从索引index开始往后移动一位
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        // 将index设置为 element 
        elementData[index] = element;
		// 数组实际元素值 +1
        size++;
    }

addAll(int index, Collection<? extends E> c) 方法 添加另外一个集合从指定索引

    public boolean addAll(int index, Collection<? extends E> c) {
    	// 检测是否超过范围
        rangeCheckForAdd(index);
		
		// 将传进来的集合转换成数组
        Object[] a = c.toArray();
        // 获取要增加的长度
        int numNew = a.length;
        
        // 保证有足够的空间添加元素
        ensureCapacityInternal(size + numNew);  // Increments modCount
		
		// 获取要添加位置的索引
        int numMoved = size - index;
        // 大于0 将elementData 向后移动 numNew 个位置
        if (numMoved > 0)
            System.arraycopy(elementData, index, elementData, index + numNew,
                             numMoved);
		// 将传递过来的集合元素添加到 elementData中
        System.arraycopy(a, 0, elementData, index, numNew);
        size += numNew; // 数组存储元素数目 +上 numNew
        return numNew != 0;  // 如果为true代表添加成功
    } 
	// 检测添加的范围是否合法
	 private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

remove() 方法

// 删除指定索引的元素
 public E remove(int index) {
 		// 判断索引是否在集合的索引中
        rangeCheck(index);

        modCount++;  // 修改次数+1
        
        // 获取到要删除的元素
        E oldValue = elementData(index);

		// 将数组从索引位开始 向前移动一位
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        // 数组实际元素大小 -1  并将最后一个元素赋值为null
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;  // 返回删除的元素
    }
    // 检测范围是否合法的方法
	 private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

remove(Object o) 方法

// 移除指定元素的方法
 public boolean remove(Object o) {
 		// 判断要删除的是否为null
        if (o == null) {
        	// 遍历数组，然后判断内容是否为null
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);	// 实际删除的方法 将要删除的索引传递过去
                    return true; // 返回 true代表删除成功
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }
	// 实际的删除方法
 private void fastRemove(int index) {
        modCount++; // 修改次数 +1
        int numMoved = size - index - 1; // 获取数组要移动的索引
        // 如果大于0则将数组从索引位+1 向前移动一位 使用System.arraycoy（）方法
        if (numMoved > 0) 
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        // 数组实际存储元素的数量-1 并将最后一位的元素值赋值为null
        elementData[--size] = null; // clear to let GC do its work
    }
唯心而动唯刃而行
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java.util包
02-13
java.util包
介绍 java.util 包 (转贴)
allenjay2003的专栏
01-02 2056
ArrayList是List接口的一个可变长数组实现。实现了所有List接口的操作，并允许存储null值。除了没有进行同步，ArrayList基本等同于Vector。在Vector中几乎对所有的方法都进行了同步，但ArrayList仅对writeObject和readObject进行了同步，其它比如add(Object)、remove(int)等都没有同步。1.存储ArrayList使用一个Obj
Java.util包中常用的类
GarfieldEr007的专栏
09-29 4002
Java.util包 Java.util.ArrayDeque类 Java.util.ArrayList类 Java.util.Arrays类 Java.util.BitSet类 Java.util.Calendar类 Java.util.Collections类 Java.util.Currency类 java.util.Date类 java.util.Dictionary类
java util包
kkkkk777的博客
05-06 181
–Array– Array类提供静态方法来动态创建和访问Java数组。 --------------------------------------------------------------- static Object newInstance(类<?> componentType, int length) 创建具有指定组件类型和长度的新数组。 -----------------...
ArrayList 源码深度解析
01-20
ArrayList 源码深度解析 一、重新认识ArrayList 什么是ArrayList？ ArrayList是基于数组实现的List类，封装了一个动态再分配的Object数组，以达到可以动态增长和缩减的索引序列。 长啥样？ 如图，是一个长度为6，...
ArrayList源码.zip
03-13
本压缩包文件“ArrayList源码.zip”包含ArrayList的源代码，可以帮助我们深入理解其内部工作原理和优化策略。 ArrayList的核心实现是通过一个Object类型的数组来存储元素。当添加元素时，如果当前容量不足，...
ArrayList源码分析
01-20
它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable的方法，我们从它的源码中可以清楚的看到 //默认的初始化容量为10 private static final int DEFAULT_CAPACITY = 10; //用于...
Java ArrayList源码剖析
12-22
　ArrayList实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量（capacity），表示...
java-util包资料
12-29
java-util包资料:有关util的介绍
JAVA util工具包
03-14
JAVA开发Util工具包，小集合，多平带扩展。JAVA开发Util工具包，小集合，多平带扩展
java自己整理Util包
03-28
NULL 博文链接：https://lochen514.iteye.com/blog/1262726
深入剖析jdk的java.util包
05-17
jdk源码java.util包，所有类解析，包含整体架构及各个类详解
java.util包（java工具包）
最新发布
zhizunruwo的博客
02-01 340
Calemdar表示一个日历，此类可以用来处理时间，通常可以和Date结合着使用，就像String-->StringBuffer;可以获得年，月，日，小时，秒，星期几，一年中的第几天等；内部通过一个long值来表示当前时间的毫秒值；参考的时间是1970年1月1日0时0分0秒0毫秒；此包中包含了很多集合类，属性类，日期类等；但内部有一个方法，可以获得表示当前时间的实例；Random表示随机数生成器，它可以用来生成各种类型的随机数；表示一个时刻，可以精确到毫秒值，此类主要用来存储时间；Date(long);
Java:java.util包
路之痕
06-18 424
java.util包含集合框架、遗留的 collection 类、事件模型、日期和时间设施、国际化和各种实用工具类（字符串标记生成器、随机数生成器和位数组、日期Date类、堆栈Stack类、向量Vector类等）。集合类、时间处理模式、日期时间工具等各类常用工具包。Collection 接口：扩展了Iterable接口，位于集合层次结构的顶部，因此所有的集合都实现Collection接口，并提供了i
arraylist源码
07-09
以下是 Java 中 ArrayList 类的简化版源码： ```java public class ArrayList<E> implements List<E> { private static final int DEFAULT_CAPACITY = 10; private Object[] elementData; private int size; public ArrayList() { this.elementData = new Object[DEFAULT_CAPACITY]; this.size = 0; } public void add(E element) { if (size == elementData.length) { expandCapacity(); } elementData[size++] = element; } private void expandCapacity() { int newCapacity = elementData.length * 2; Object[] newElementData = new Object[newCapacity]; System.arraycopy(elementData, 0, newElementData, 0, size); elementData = newElementData; } public E get(int index) { if (index < 0 || index >= size) { throw new IndexOutOfBoundsException(); } return (E) elementData[index]; } public int size() { return size; } } ``` 这是一个简单的 ArrayList 实现，它使用一个数组来存储元素，并根据需要动态调整数组的大小。ArrayList 实现了 List 接口，提供了添加元素、获取元素和获取列表大小等基本操作。请注意，这只是一个简化的版本，真实的 ArrayList 源码会更加复杂和完整。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值