ArrayList底层源码学习

最新推荐文章于 2025-05-12 11:50:17 发布
最新推荐文章于 2025-05-12 11:50:17 发布
阅读量255 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/chenlibao0823/article/details/86599295
本文详细解析了数组的基本操作，包括add、get、set、remove和indexOf等方法的实现原理。重点介绍了数组扩容机制，当元素数量达到数组容量时，如何通过创建新数组并复制元素来实现扩容。同时，阐述了各种操作的具体步骤，如添加元素时的index位置选择，获取、设置和删除元素的方法，以及查找元素位置的过程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

主要为add, get, set, remove, indexOf，数组扩容等内容的学习。

扩容：
扩容前提：size==elementData.length，也就是元素个数达到了数组容器的长度。
创建新的更大空间的（如size*2+1)数组对象，

Object[] newArray = new Object[size*2+1]

遍历原来数组元素，复制到新数组中，在将这个新数组重新赋值给同名字的elementData。

public Object[] grow() {
		if (size == elementData.length) {
			Object[] newArray = new Object[size*2+1];
			for (int i=0; i<elementData.length; i++) {
				newArray[i] = elementData[i];
			}
			elementData = newArray;
		}
		return elementData;
	}

数组添加元素：

elementData[s] = element;
size++;

记得不要忘了添加size++, 添加元素，size相应增大。
相反，remove元素后，不要忘了"- - size"。

1、add
类内部调用的add方法：先扩容，然后在index=size位置处，添加元素，size++

	private void add(E e, Object[] obj, int s) {
		elementData = grow();
		elementData[s] = e;
		size++;
	}

add (element)：直接调用上方的内部类的私有方法add

	public boolean add(E e) {
		add(e, elementData, size);
		return true;
	}

add (index, element)：先扩容，然后将index位置到最后的元素，全部往后挪一个位置，也就是复制到index+1，在将目标元素放入到数组index位置处，size++。

	public boolean add(int index, E element) {
		indexCheck(index);
		// 扩容
		elementData = grow();
		System.arraycopy(elementData, index, elementData, index+1, size-index);
		elementData[index] = element;
		size++;
		return true;
	}

2、get
get实际上就是用index从数组中取值

	public Object get(int index) {
		indexCheck(index);
		return elementData[index];
	}

3、remove
原理就是将index+1到最后的元素，往前挪一个位置，最后一个元素设为null，size-1。

	public E remove(int index) {
		indexCheck(index);
		E oldValue = (E) elementData[index];
		System.arraycopy(elementData, index+1, elementData, index, size-index-1);
		elementData[--size] = null;
		return oldValue;
	}

4、set
这个简单，直接将数组index位置处，赋值为目标元素。

	public boolean set(int index, E e) {
		elementData[index] = e;
		return true;
	}

5、indexOf
其实遍历数组，用equals来判断是否存在目标元素，有就返回对应 i，没有就返回-1.

public int indexOf(Object obj) {
		return indexOfRange(obj, 0, size);
	}
	
	
public int indexOfRange(Object obj, int start, int end) {
		if (obj == null) {
			for (int i=start; i<end; i++) {
				if (elementData[i] == null) {
					return i;
				}
			}
		} else {
			for (int i=start; i<=end; i++) {
				if (obj.equals(elementData[i])) {
					return i;
				}
			}
			
		}
		return -1;
	}

整体代码

package cn.sxt.oop.datastructure;

/**
 * practice of add()
 * add(index, element)或者add(element)两种添加元素方法，都需要考虑：扩容的问题，第二，要记得加size++，不然元素会变少
 * @author t_chenli
 * @param <E>
 *
 */
public class ArrayListAddPra<E> {

	Object[] elementData;
	private int size;
	private final Object[] EMPTY_ELEMENTDATA = {};
	
	public ArrayListAddPra() {
		this.elementData = EMPTY_ELEMENTDATA;
	}
	
	public ArrayListAddPra(int initialCapacity) {
		if (initialCapacity > 0) {
			elementData = new Object[initialCapacity];
		} else if (initialCapacity == 0) {
			elementData = EMPTY_ELEMENTDATA;
		} else {
			try {
				throw new Exception();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}	
	}
	
	public int size() {
		return size;
	}
	
	private void add(E e, Object[] obj, int s) {
		elementData = grow();
		elementData[s] = e;
		size++;
	}
	
	public boolean add(E e) {
		add(e, elementData, size);
		return true;
	}
	
	public Object[] grow() {
		if (size == elementData.length) {
			Object[] newArray = new Object[size*2+1];
			for (int i=0; i<elementData.length; i++) {
				newArray[i] = elementData[i];
			}
			elementData = newArray;
		}
		return elementData;
	}
	
	public boolean add(int index, E element) {
		indexCheck(index);
		//o 扩容
		elementData = grow();
		System.arraycopy(elementData, index, elementData, index+1, size-index);
		elementData[index] = element;
		size++;
		return true;
	}
	
	public Object get(int index) {
		indexCheck(index);
		return elementData[index];
	}
	
	public boolean set(int index, E e) {
		elementData[index] = e;
		return true;
	}
	
	public E remove(int index) {
		indexCheck(index);
		E oldValue = (E) elementData[index];
		System.arraycopy(elementData, index+1, elementData, index, size-index-1);
		elementData[--size] = null;
		return oldValue;
	}
	
	public int indexOf(Object obj) {
		return indexOfRange(obj, 0, size);
		
	}
	
	
	public int indexOfRange(Object obj, int start, int end) {
		if (obj == null) {
			for (int i=start; i<end; i++) {
				if (elementData[i] == null) {
					return i;
				}
			}
		} else {
			for (int i=start; i<=end; i++) {
				if (obj.equals(elementData[i])) {
					return i;
				}
			}
			
		}
		return -1;
	}
	
	private void ensureCapacity() {
		if (size == elementData.length) {
			
			try {
				throw new Exception();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
	
	private void indexCheck(int index) {
		if (index<0 || index>=size) {
			try {
				throw new Exception();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
	
	public static void main(String[] args) {
		ArrayListAddPra list = new ArrayListAddPra();
		list.add("aaa");
		list.add("bbb");
		list.add(123);
		list.add(new Pandas());
		list.add(new String("one string"));
		
		System.out.println("######### add(element) test #############");
		for (int i=0; i<list.size(); i++) {
			System.out.println(list.get(i));
		}
		System.out.println("size: "+list.size());
		System.out.println("######### add(index,element) test #############");
		list.add(1, "Libao");
		for (int i=0; i<list.size(); i++) {
			System.out.println(list.get(i));
		}
		System.out.println("size: "+list.size());
		System.out.println("######### set(index, element) test  #############");
		list.set(1, "111");
		for (int i=0; i<list.size(); i++) {
			System.out.println(list.get(i));
		}
		System.out.println("size: "+list.size());
		System.out.println("#########  remove(index) test ###########");
		list.remove(0);
		for (int i=0; i<list.size(); i++) {
			System.out.println(list.get(i));
		}
		System.out.println("size: "+list.size());
		
		System.out.println("######### indexOf(obj) test  ############");
		System.out.println("index of 123: " + list.indexOf(123));
		System.out.println("index of bbb: " + list.indexOf("bbb"));
		
		System.out.println("######### 扩容 test #############");
		for (int i=1; i<11; i++) {
			list.add(i);
		}
		for (int i=0; i<list.size(); i++) {
			System.out.println(list.get(i));
		}
		System.out.println("size: "+list.size());
	}
}

class Pandas {
	
}

结果：

######### add(element) test #############
aaa
bbb
123
cn.sxt.oop.datastructure.Pandas@368239c8
one string
size: 5
######### add(index,element) test #############
aaa
Libao
bbb
123
cn.sxt.oop.datastructure.Pandas@368239c8
one string
size: 6
######### set(index, element) test #############
aaa
111
bbb
123
cn.sxt.oop.datastructure.Pandas@368239c8
one string
size: 6
######### remove(index) test ###########
111
bbb
123
cn.sxt.oop.datastructure.Pandas@368239c8
one string
size: 5
######### indexOf(obj) test ############
index of 123: 2
index of bbb: 1
######### 扩容 test #############
111
bbb
123
cn.sxt.oop.datastructure.Pandas@368239c8
one string
1
2
3
4
5
6
7
8
9
10
size: 15

ArrayList底层源码大总结（扩容机制和初始化）
2301_77615930的博客
04-29 1069
ArrayList底层源码详解。将他的底层逻辑详细的呈现给你
ArrayList底层源码解析
weixin_56777219的博客
05-25 443
ArrayList源码底层解析
ArrayList底层源码和LinkedList底层源码
最新发布
2302_76363587的博客
05-12 182
如果一次添加多个元素，1.5倍还放不下，则新创建数组的长度以实际为准。利用空参创建的集合，在底层创建一个默认长度为0的数组。添加第一个元素时，底层会创建一个新的长度为10的数组。存满时，会扩容1.5倍。
ArrayList底层源码分析
m0_61750910的博客
02-27 265
List<Integer> list = new ArrayList<>(); public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; }
ArrayList 底层源码分析
燕归来兮
07-12 215
原文链接 https://www.zhoutao123.com/page/book/java/category/irpont 更多文章欢迎访问 https://www.zhoutao123.com ArrayList 是我们在日常开发中经常使用的一个类，其位于 java.util 包下，底层使用了数组来实现，在继承关系上如下所示 父类是Collect，说明其是对象的容器 继承了 RandomAccess 表明可以随机访问 继承Serializable标识可以被序列化 继承Clon..
ArrayList底层代码
阳哥的博客
09-09 310
1、首先我们创建一个ArrayList数组 ArrayList a=new ArrayList(); 2、点到底层后，发现我们需要的属性： transient Object[] elementData; // non-private to simplify nested class access 这是一个瞬态对象的元素数据、非私有以简化嵌套类访问 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}
ArrayList底层原理以及使用技巧
热门推荐
xu404741377的博客
06-29 1万+
ArrayList简介 ArrayList是我们在开发中非常常用的数据存储容器之一，其底层是数组实现的，我们可以在集合中存储任意类型的数据。ArrayList又是线程不安全的，这在接下来代码分析的过程中会有体现。ArrayList非常适合对元素进行查找，效率非常高。 源码分析 既然是分析源码，那我们先从构造函数开始。我们常用的构造函数有两个，分别是有参和无参的，如下图 无参
ArrayList底层原理源码分析
cydbetter的博客
05-18 813
我们知道list集合的底层是数组，可是究竟如何扩容的呢？以下分析基于JDK1.7版本。1.当你new一个集合时，ArrayList&lt;String&gt; list = new ArrayList&lt;String&gt;();private static final Object[] EMPTY_ELEMENTDATA = {}; private transient Object[] e...
ArrayList底层源码简单了解
ljc552010807的博客
01-15 242
1、ArrayList的底层实际上是一个Object数组，我们可以看到它的空参构造方法是把Object数组指向了一个长度为0的Object数组。 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = new Object[0]; transient Object[] elementData; public ArrayList() { this.elementData = DEFAULTCAPACITY_
ArrayList底层源码和原理详解
qq_41972358的博客
05-21 502
Java中并不是所有数据都能存到数组中去，只有像同数据才可以一起存储到数组中。 数组的查询速度快，增删比较慢。 原因：数组在存储数据时时按顺序存储的，存储数据的内存也是连续的，所以他们的特点就是寻址读取数据比较容易，插入和删除比较困难。 数组删除的时候，简单当数组某个下标位子数据删除后，后面的数据会自动填充上，那么就比较耗时。 ALT+7可以看到类中的方法。 JDK1.7的ArrayList内部的方法。 无参的构造方法： public ArrayList() { super(); this.elementD
ArrayList 底层源码详解
y13672651519的博客
08-01 752
      我们先复习一下ArrayList：它封装了一系列操作，如增删改查，对比使用传统的数组方便了很多，因为java代码已经替我们写好了，我们直接用即可。       但是，面对即将走向工作岗位的你们，单单知道如何使用远远不够，首先面试官就是一个槛，大部分面试都会问集合的实现原理，这也是大部分面试者的薄弱点。       我们
ArrayList底层源代码分析
技术杠精的博客
09-16 234
一、前言 ArrayList就不赘述了，线程不安全、底层数据结构是数组、查询快、增删慢等等 二、源码分析 ArrayList的初始容量？ArrayList的扩容规则？ /** * Shared empty array instance used for default sized empty instances. We * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate wh
【Javase】ArrayList底层代码实现
古怪的小窝
03-08 713
ArrayList底层其实是Object[] 数组，并且初始大小是10 还可以通过构造函数，创建默认大小长度的ArrayList，如果小于0，会抛出异常信息。 ArrayList扩容的过程： 1.先判断长度是否够用 2.移动元素 3.插入元素
ArrayList底层实现源码解析
qq_33696779的博客
04-09 374
package com.collection; import java.util.ArrayList; import java.util.List; /**  * 模拟ArrayList底层实现基础方法   * @author Mrzhang  *  * @param  */ public class MyArrayList { //基础数组长度设置  privat
ArrayList 源码
ironmanoOOoo的博客
07-22 1794
集合类中，最基础也是最常用的，大概就是ArrayList了吧。ArrayList的本质，是一个可变长的数组。那有人可能就会问，哎呀这个数组老简单了，有什么好看的啊……但事实上，在面试时，有些人还是对源码的细节说不清楚，从而留下较差的印象。这里，我就带着大家，一点一点地梳理一下，ArrayList的底层源码吧。概览..ArrayList类继承自AbstractList类，且实现了List、RandomAccess、Cloneable和Serializable接口。...
ArrayList底层结构和源码分析
weixin_43752912的博客
06-08 251
ArrayList扩容机制 ArrayList的底层操作机制源码分析(重点，难点.)ArrayListSource.java ，先说结论，在分析源码(示意图)ArrayList中维护了一个Object类型的数组elementData.[debug看源码] transient Object[] elementData; //transient表示瞬间,短暂的,表示该属性不会被序列化当创建ArrayList对象时，如果使用的是无参构造器，则初始elementData容量...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值