ArrayList源码分析

最新推荐文章于 2024-07-10 21:37:49 发布
最新推荐文章于 2024-07-10 21:37:49 发布
阅读量196 收藏
点赞数 1
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44971379/article/details/123421114
版权

构造方法

ConstructorConstructor描述
ArrayList()构造一个初始容量为十的空列表。
ArrayList(int initialCapacity)构造具有指定初始容量的空列表。
ArrayList(Collection<? extendsE> c)构造一个包含指定集合的元素的列表,按照它们由集合的迭代器返回的顺序。
ArrayList()
public class Test01 {

	public static void main(String[] args) {
		//这行代码做了什么?
		//真的构造一个初始容量为十的空列表?
		ArrayList<String> list = new ArrayList<String>();
	}
}
  • 源码
public class ArrayList<E> {

	/**
	 * 默认初始容量
	 */
	private static final int DEFAULT_CAPACITY = 10;
	/**
	 * 空数组
	 */
	private static final Object[] EMPTY_ELEMENTDATA = {};
	/**
	 * 默认容量的空数组
	 */
	private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
	/**
	 * 集合真正存储数组元素的数组
	 */
	transient Object[] elementData;
	/**
	 * 集合的大小
	 */
	private int size;

	public ArrayList() {
		this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
	}
}

Q： 默认空容量，是什么时候放进去的？

ArrayList(int initialCapacity)
public class Test01 {

	public static void main(String[] args) {
		//这行代码ArrayList底层做了什么?
		ArrayList<String> list = new ArrayList<String>(5);
	}
}
  • 源码
public class ArrayList<E> {

	public ArrayList(int initialCapacity) { //initialCapacity = 5
		//判断初始容量initialCapacity是否大于0
		if (initialCapacity > 0) {
			//创建一个数组,且指定长度为initialCapacity
			this.elementData = new Object[initialCapacity];
		} else if (initialCapacity == 0) {
			//如果initialCapacity容量为0,把EMPTY_ELEMENTDATA的地址赋值给elementData
			this.elementData = EMPTY_ELEMENTDATA;
		} else {
			//以上两个条件都不满足报错
			throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
		}
	}
}
ArrayList(Collection<? extends E> c)
public class Test01 {

	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();
		list.add("aaa");
		list.add("bbb");
		list.add("ccc");
		//这行代码做了什么?
		ArrayList<String> list1 = new ArrayList<>(list);
		for (String s : list1) {
			System.out.println(s);
		}
	}
}
  • 源码
public class ArrayList<E> {

	public ArrayList(Collection<? extends E> c) {
		// 将集合构造中的集合对象转成数组,且将数组的地址赋值给elementData
		elementData = c.toArray();
		// 将elementData的长度赋值给 集合长度size,且判断是否不等于 0
		if ((size = elementData.length) != 0) {
			// 判断elementData 和 Object[] 是否为不一样的类型
			if (elementData.getClass() != Object[].class)
				//如果不一样,使用Arrays的copyOf方法进行元素的拷贝
				elementData = Arrays.copyOf(elementData, size, Object[].class);
		} else {
			// 用空数组代替
			this.elementData = EMPTY_ELEMENTDATA;
		}
	}

	//将集合转数组的方法
	public Object[] toArray() {
		//调用数组工具类方法进行拷贝
		return Arrays.copyOf(elementData, size);
	}
}

//数组工具类
public class Arrays {

	public static <T> T[] copyOf(T[] original, int newLength) {
		//再次调用方法进行拷贝
		return (T[]) copyOf(original, newLength, original.getClass());
	}

	public static <T, U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
		//用三元运算符进行判断,不管结果如何都是创建一个新数组
		T[] copy = ((Object) newType == (Object) Object[].class) ?
				(T[]) new Object[newLength] :
				(T[]) Array.newInstance(newType.getComponentType(), newLength);
		//将数组的内容拷贝到 copy 该数组中
		System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
		//返回拷贝元素成功后的数组
		return copy;
	}
}

R：复制前提: 长度大与0 && 集合元素类型不为Object.class()?

添加方法

方法名描述
public boolean add(E e)将指定的元素追加到此列表的末尾。
public void add(int index, E element)在此列表中的指定位置插入指定的元素。
public boolean addAll(Collection<?extends E> c)按指定集合的Iterator返回的顺序将指定集合中的所有元素追加到此列表的末尾。
public boolean addAll(i nt index,Collection<? extends E> c)将指定集合中的所有元素插入到此列表中,从指定的位置开始。
public boolean add(E e)
public class Test01 {

	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<>();
		list.add("黑马程序员");
	}
}
  • 源码
public class ArrayList<E> {

	//将添加的数据传入给 e
	public boolean add(E e) {
		//调用方法对内部容量进行校验-》size为目前集合的长度，方法为新增操作，长度+1
		ensureCapacityInternal(size + 1);
		//将元素添加到末尾，并且将长度加1
		elementData[size++] = e;
		return true;
	}

	/**
	 *
	 * @param minCapacity ： 数组容量：最小也的这么大
	 */
	private void ensureCapacityInternal(int minCapacity) {
		//判断集合存数据的数组是否等于空容量的数组
		if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
			//通过最小容量和默认容量 求出较大值 (用于第一次扩容)
			minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
		}
		//将if中计算出来的容量传递给下一个方法,继续校验
		ensureExplicitCapacity(minCapacity);
	}

	/**
	 *
	 * @param minCapacity ： 数组容量：最小也的这么大
	 */
	private void ensureExplicitCapacity(int minCapacity) {
		//实际修改集合次数++ (在扩容的过程中没用,主要是用于迭代器中)
		modCount++;
		//判断最小容量 - 数组长度是否大于 0
		if (minCapacity - elementData.length > 0)
			//到此说明容量不够
			//将第一次计算出来的容量传递给 核心扩容方法
			grow(minCapacity);
	}

	private void grow(int minCapacity) {
		//记录数组的实际长度,此时由于木有存储元素,长度为0
		int oldCapacity = elementData.length;
		//核心扩容算法 原容量的1.5倍
		int newCapacity = oldCapacity + (oldCapacity >> 1);
		//判断新容量 - 最小容量 是否小于 0, 如果是第一次调用add方法必然小于
		if (newCapacity - minCapacity < 0)
			//还是将最小容量赋值给新容量
			newCapacity = minCapacity;
		//判断新容量-最大数组大小 是否>0,如果条件满足就计算出一个超大容量
		if (newCapacity - MAX_ARRAY_SIZE > 0)
			newCapacity = hugeCapacity(minCapacity);
		// 调用数组工具类方法,创建一个新数组,将新数组的地址赋值给elementData
		elementData = Arrays.copyOf(elementData, newCapacity);
	}
}
public void add(int index, E element)
public class Test01 {

	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<>();
		list.add("111");
		list.add("222");
		list.add("333");
		list.add(1, "444");
		System.out.println(list);
	}
}
  • 源码
public class ArrayList<E> {

	public void add(int index, E element) {
		//添加范围检查
		rangeCheckForAdd(index);
		//调用方法检验是否要扩容,且让增量++
		ensureCapacityInternal(size + 1);
		/**
		 * 核心实现：在index插入元素，先把之前在index做为起始，直到末尾的尾段段数据，向后移一位
		 */
		System.arraycopy(elementData, index, elementData, index + 1, size - index);
		elementData[index] = element;
		size++;
	}

	private void rangeCheckForAdd(int index) {
		//超出指定范围就报错
		if (index > size || index < 0)
			throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
	}

	private void ensureCapacityInternal(int minCapacity) {
		if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
			minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
		}
		//确保明确的能力
		ensureExplicitCapacity(minCapacity);
	}

	private void ensureExplicitCapacity(int minCapacity) {
		//增量++ (也就是实际修改集合的次数)
		modCount++;
		//如果再调用 add(index,element) 方法之前已经扩容,那么源码跟踪到此结束
		//不会进行扩容
		if (minCapacity - elementData.length > 0)
			grow(minCapacity);
	}
}
arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
public final class System {
	参数
	src - 源数组。
	srcPos - 源数组中的起始位置。
	dest - 目标数组。
	destPos - 目的地数据中的起始位置。
	length - 要复制的数组元素的数量。
	public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
}
  • 将 src 数组，从 srcPos 位置起始的 length，复制到目标数组 dest，复制的起始位置为 destPos
public boolean addAll(Collection<?extends E> c)
public class Test01 {

	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<>();
		list.add("黑马程序员");
		list.add("传智播客");
		list.add("传智大学");
		ArrayList<String> list1 = new ArrayList<>();
		list1.addAll(list);
		System.out.println(list);
		System.out.println(list1);
	}
}
  • 源码
public class ArrayList<E> {

	public boolean addAll(Collection<? extends E> c) {
		//把集合的元素转存到Object类型的数组中
		Object[] a = c.toArray();
		//记录数组的长度
		int numNew = a.length;
		//调用方法检验是否要扩容,且让增量++
		ensureCapacityInternal(size + numNew);
		//调用方法将a数组的元素拷贝到elementData数组中--》将目标数组拼接在原数组的尾部
		System.arraycopy(a, 0, elementData, size, numNew);
		//集合的长度+=a数组的长度
		size += numNew;
		//只要a数组的长度不等于0,即说明添加成功
		return numNew != 0;
	}
}
public boolean addAll(int index, Collection<? extends E> c)
public class Test01 {

	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<>();
		list.add("黑马程序员");
		list.add("传智播客");
		list.add("传智大学");
		ArrayList<String> list1 = new ArrayList<>();
		list1.add("酷丁鱼");
		//在指定索引处添加一个集合list1.addAll(1,list);
		System.out.println(list);
		System.out.println(list1);
	}
}
  • 源码
public class ArrayList<E> {
	//长度为0的空数组
	private static final Object[] EMPTY_ELEMENTDATA = {};
	//默认容量为空的数组
	private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
	//集合存元素的数组
	Object[] elementData;
	//集合的长度
	private int size;
	//默认的容量
	private static final int DEFAULT_CAPACITY = 10;
	public boolean addAll(int index, Collection<? extends E> c) {
		//校验索引
		rangeCheckForAdd(index);
		//将数据源转成数组
		Object[] a = c.toArray();
		//记录数据源的长度 3
		int numNew = a.length;
		//目的就是为了给集合存储数据的数组进行扩容
		ensureCapacityInternal(size + numNew);
		/**
		 * 先把位置空出来，然后将数组进行填充
		 */
		//numMoved:代表要移动元素的个数 --> 1个
		//numMoved: 数据目的(集合list1)的长度-调用addAll的第一个参数 (索引1)
		int numMoved = size - index;
		//判断需要移动的个数是否大于0
		if (numMoved > 0)
			//使用System中的方法arraycopy进行移动
			System.arraycopy(elementData, index, elementData, index + numNew,
							 numMoved);
		//才是真正将数据源(list)中的所有数据添加到数据目的(lsit1)
		System.arraycopy(a, 0, elementData, index, numNew);
		size += numNew;
		return numNew != 0;
	}
	private void rangeCheckForAdd(int index) {
		if (index > size || index < 0)
			throw new IndexOutOfBoundsException(outOfBoundsMsg(index));}
}

删除方法

public E remove(int index) 按索引位置移除
public class Test01 {

	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<>();
		list.add("山东大李逵");
		list.add("天魁星宋江");
		list.add("天罡星卢俊义");
		list.add("西门大人");
		//根据索引删除元素
		String value = list.remove(3);
		System.out.println("删除的元素为: " + value);
		System.out.println("集合的元素: " + list);
	}
}
  • 源码
public class ArrayList<E> {

	public E remove(int index) {
		//范围校验
		rangeCheck(index);
		//增量++
		modCount++;
		//将index对应的元素赋值给 oldValue
		E oldValue = elementData(index);
		//计算集合需要移动元素个数
		int numMoved = size - index - 1;
		//如果需要移动元素个数大于0,就使用arrayCopy方法进行拷贝
		//注意:数据源和数据目的就是elementData
		if (numMoved > 0)
			System.arraycopy(elementData, index + 1, elementData, index, numMoved);
		//将源集合最后一个元素置为null,尽早让垃圾回收机制对其进行回收
		//数组长度要减1 && 末尾元素要置空
		elementData[--size] = null;
		//返回被删除的元素
		return oldValue;
	}
}
public boolean remove(Object o) 按对象进行移除
public class Test01 {

	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<>();
		list.add("山东大李逵");
		list.add("天魁星宋江");
		list.add("西门大人");
		list.add("天罡星卢俊义");
		//根据索引删除元素boolean flag = list.remove("西门大人");
		System.out.println("是否删除成功: " + flag);
		System.out.println("集合的元素: " + list);
	}
}
  • 源码
public class ArrayList<E> {

	public boolean remove(Object o) {
		//判断要删除的元素是否为null
		if (o == null) {
			//遍历集合
			for (int index = 0; index < size; index++)
				//判断集合的元素是否为null
				if (elementData[index] == null) {
					//如果相等,调用fastRemove方法快速删除
					fastRemove(index);
					return true;
				}
		} else {
			//遍历集合
			for (int index = 0; index < size; index++)
				//用o对象的equals方法和集合每一个元素进行比较
				if (o.equals(elementData[index])) {
					//如果相等,调用fastRemove方法快速删除
					fastRemove(index);
					return true;
				}
		}
		//如果集合没有o该元素,那么就会返回false
		return false;
	}

	//快速删除：数据移动
	private void fastRemove(int index) {//增量++
		modCount++;
		//计算集合需要移动元素的个数
		int numMoved = size - index - 1;
		//如果需要移动的个数大于0,调用arrayCopy方法进行拷贝
		if (numMoved > 0)
			System.arraycopy(elementData, index + 1, elementData, index, numMoved);
		//将集合最后一个元素置为null,尽早被释放
		elementData[--size] = null;
	}
}

修改方法

public E set(int index, E element) 根据索引修改集合元素
public class Test01 {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<>();
		list.add("山东大李逵");
		list.add("天魁星宋江");
		list.add("天罡星卢俊义");
		list.add("西门大人");
		//根据索引修改集合元素
		String value = list.set(3, "花和尚鲁智深");
		System.out.println("set方法返回值: "+value);
		System.out.println("集合的元素: "+list);
	}
}
  • 源码
public class ArrayList<E> {

	public E set(int index, E element) {
		//范围校验
		rangeCheck(index);
		//先取出index对应的元素,且赋值给oldValue
		E oldValue = elementData(index);
		//将element直接覆盖index对应的元素
		elementData[index] = element;
		//返回被覆盖的元素
		return oldValue;
	}

	private void rangeCheck(int index) {
		if (index >= size)
			throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
	}
}

获取方法

public E get(int index) 根据索引获取元素
public class Test01 {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<>();
		list.add("山东大李逵");
		list.add("天魁星宋江");
		list.add("天罡星卢俊义");
		list.add("西门大人");
		//根据索引获取集合元素
		String value = list.get(1);
		System.out.println("get方法返回值: "+value);
		System.out.println("集合的元素: "+list);
	}
}
  • 源码
public class ArrayList<E> {
	public E get(int index) {
		//范围校验
		rangeCheck(index);
		//直接根据索引取出集合元素
		return elementData(index);
	}
	private void rangeCheck(int index) {
		if (index >= size)
			throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
	}
}

清空方法

public void clear() 清空集合所有数据
public class Test01 {

	public static void main(String[] args) {
		//创建集合对象
		List<String> list = new ArrayList<String>();
		//添加元素
		list.add("hello");
		list.add("PHP");
		list.add("Java");
		System.out.println("清空前的集合: " + list);
		//清空集合所有元素
		list.clear();
		System.out.println("清空后的集合: " + list);
	}
}
  • 源码
public class ArrayList<E> {
	public void clear() {
		//实际修改集合次数++
		modCount++;
		//遍历集合,将集合每一个索引对应位置上的元素都置为null,尽早让其释放
		for (int i = 0; i < size; i++)
			elementData[i] = null;
		//集合长度更改为0
		size = 0;
	}
}

包含方法

public boolean contains(Object o) 判断集合是否包含指定元素
public class Test01 {

	public static void main(String[] args) {
		//创建集合对象
		List<String> list = new ArrayList<String>();
		//添加元素
		list.add("hello");
		list.add("PHP");
		list.add("Java");
		System.out.println("判断之前集合的元素: " + list);
		//需求:如果集合中没有JavaSE该元素,请添加一个JavaSE元素
		//解决方式一:循环遍历集合,判断集合是否包含JavaSE,如果没有包含就调用集合的add方法进行添加操作
		//解决方式二:使用集合contains方法判断,根据判断的结果决定是否要添加元素
		if (!list.contains("JavaSE")) {
			list.add("JavaSE");
		}
		System.out.println("判断之后集合的元素: " + list);
	}
}
  • 源码
public class ArrayList<E> {

	//源码contains方法
	public boolean contains(Object o) {
		//调用indexOf方法进行查找
		return indexOf(o) >= 0;
	}

	public int indexOf(Object o) {
		//如果元素是null,也进行遍历操作
		//因为集合中有可能够会存储null
		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;
		}
		//如果没有走if,也没有走else,那么就说明o该元素在集合中不存在
		return -1;
	}
}
knowledge are power
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
12. ArrayList测试代码
changshuchao的博客
03-13 283
1.iterator，边遍历边删除 public class TestArrayList { public static void main(String[] args) { ArrayList&amp;lt;Integer&amp;gt; list = new ArrayList&amp;lt;&amp;gt;(); list.add(1); list.add(2); ...
JAVA入门6
qq_50695080的博客
10-24 196
int与String之间的相互转换: int--->String: 方式1:空串拼接:用+拼接一个空字符串. 方式2:String类的拼接功能:public String append(任意数据类型){} int i = 100 ; String str = "" ; str.append(i); 方式3:利用包装类类型Integer:Inter类的构造方法Integer(int i)+成员方法String toString() int i = 100 ; Integer ii = n
一篇文章带你搞定 Java 中的 List 接口
南淮北安的博客
02-13 841
文章目录一、List 接口的定义二、List接口的常用子类1. 新的子类：ArrayList（1）向集合中增加元素（2）实例操作二：删除元素（3）实例操作三：输出 List 中的内容（4）实例操作四：将集合变为对象数组（5）实例操作五：集合的其他相关操作2. LinkedList 子类与 Queue 接口（1）实例操作一：在链表的开头和结尾增加数据（2）实例操作二：找到链表头（3）实例操作三：以先...
ArrayList 源码分析
搬运Gong
03-23 941
ArrayList的初始化过程及动态扩容机制源码分析
java ArrayList源码分析（深度讲解）
Cyan_RA9的博客
03-13 1624
java 集合篇章——ArrayList类源码分析。通过Debug一步一步带你看懂源码!
Java编程中ArrayList源码分析
08-28
Java编程中ArrayList源码分析 Java编程中ArrayList源码分析是Java编程中一个重要的知识点，对于Java开发者来说，了解ArrayList的源码可以帮助他们更好地理解Java集合框架的实现机制，从而提高自己的编程水平。 ...
ArrayList源码分析(含jdk1.8).pdf
04-24
ArrayList的源码，写了一些自己的分析，包括jdk1.8的新特性
配置Java开发环境
最新发布
Broken_x的博客
07-10 656
Java开发环境配置
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 246
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
java Object 转 Integer
servepeople的博客
07-09 1139
在 Java 中，可以通过多种方法将一个Object转换为Integer。
java占位符替换五种方式
weixin_61478518的博客
07-08 296
在业务开发中，经常需要输出文本串。其中，部分场景下大部分文本内容是一样的，只有少部分点是不一样。简单做法是直接拼接字段，但是这会有个问题。后面如果想要修改内容，那么每个地方都要修改，这不符合设计模式中的开闭原则，面向应该对扩展开放，对修改关闭。如何解决这个问题？先来看现实生活中的例子，个人信息填写。一般会要填写表格，已经定义好了姓名，性别，年龄等字段，只要填写对应的个人信息就好了。在程序开发中，我们会预先定义好一个字符串模板，需要改动的点使用占位符。
AI技术的转变：从辨别式到生成式
学IT，找陈寒
07-09 2467
李彦宏在2024世界人工智能大会上的发言，提醒我们在AI技术发展的道路上，不要盲目追求技术本身或表面的用户数据，而应更多地关注技术的实际应用和产业价值。在大模型技术与个性化应用之间找到平衡，将是未来发展的关键。作为AI从业者和技术爱好者，我们应以务实的态度，探索AI技术在各个领域的实际应用，为产业发展和社会进步贡献力量。通过李彦宏的发言，我深刻认识到AI技术发展的方向和挑战，也更加坚定了自己在这一领域继续探索和创新的信心。未来，愿我们共同努力，推动AI技术更好地服务于社会和产业，为人类创造更美好的未来。
java中 使用数组实现需求小案例（二）
qq_44304677的博客
07-09 747
java小案例，数组需求实现，使用Random函数实现用户输入随机数生成一个打乱的数组
JavaSE 面向对象程序设计进阶 IO流 字节流详解 抛出异常
牛马程序员的博客
07-10 537
存储和读取数据的解决方案内存中数据不能永久化存储 程序停止运行 数据消失File只能对文件本身进行操作 不能读写文件里存储的数据读写数据必须要有IO流可以把程序中的数据保存到文件当中还可以把本地文件中的数据读取到数据当中。
图片压缩代码和实际操作页面
英雄汉孑的博客
07-05 1038
轻盈视界，高清依旧 —— 智能图片压缩，大容量，小体积，精彩不打折
基于SpringBoot的招聘信息管理系统的详细设计和实现(源码+lw+部署文档+讲解等，欢迎咨询我！！)
程序员阿龙的博客
07-06 1357
本次分享的是一个基于java开发的招聘信息管理系统，也说明了自己的开发实力，欢迎各位小伙伴来咨询相关业务，也可以参考一下这个文章！！
返回值处理器器【Spring源码学习】
weixin_44794897的博客
07-05 314
定义返回值类型处理器的组合；测试使用的controller测试方法。
Arraylist底层源码分析
02-20
Arraylist的底层源码是一个非常复杂的结构，它主要是由一组Object数组来实现的，并且它还使用一个计数器来跟踪元素的数量，以及一个可调节大小的容量来管理数组的大小。而且它在添加或删除元素时还会调整数组大小，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值