ArrayList源码讲解

ArrayList

底层采用的是数组队列,相当于动态数组。

ArrayList内部使用一个可重新分配的Object数组来存储元素,这个数组会随着元素的添加自动增长以容纳更多的元素,这就是所谓的“动态数组”。

1.实现了RandomAccess接口,可以随机访问
2.实现了Cloneable接口,可以克隆
3.实现了Serializable接口,可以序列化、反序列化
4.实现了List接口,是List的实现类之一
5.实现了Collection接口,是Java Collections Framework成员之一
6.实现了Iterable接口,可以使用for-each迭代

先给出源码,及其一些注解,后面会对插入和扩容进行讲解。

源码

这里给出的源码,以及中文注解,可以复制到idea中看。

public class ArrayList<E> extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, java.io.Serializable {private static final long serialVersionUID = 8683452581122892189L;
​/*** 列表默认初始大小*/private static final int DEFAULT_CAPACITY = 10;
​/*** 用于空构造方法的共享空数组实例*/private static final Object[] EMPTY_ELEMENTDATA = {};
​//用于默认大小空实例的共享空数组实例。//我们把它从EMPTY_ELEMENTDATA数组中区分出来,以知道在添加第一个元素时容量需要增加多少。private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
​
​/*** 保存ArrayList数据的数组*/transient Object[] elementData;
​/***  ArrayList元素容量** @serial*/private int size;
​/*** 带初始容量参数的构造函数(用户可以在创建ArrayList对象时自己指定集合的初始大小)*/public ArrayList(int initialCapacity) {if (initialCapacity > 0) {//如果传入的参数大于0,创建initialCapacity大小的数组this.elementData = new Object[initialCapacity];} else if (initialCapacity == 0) {//如果传入的参数等于0,创建空数组this.elementData = EMPTY_ELEMENTDATA;} else {//其他情况,抛出异常throw new IllegalArgumentException("Illegal Capacity: " +initialCapacity);}}
​/*** 默认无参构造函数* DEFAULTCAPACITY_EMPTY_ELEMENTDATA 为0.初始化为10,也就是说初始其实是空数组 当添加第一个元素的时候数组容量才变成10*/public ArrayList() {this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;}
​/*** 构造一个包含指定集合的元素的列表,按照它们由集合的迭代器返回的顺序。*/public ArrayList(Collection<? extends E> c) {//将指定集合转换为数组elementData = c.toArray();//如果elementData数组的长度不为0if ((size = elementData.length) != 0) {// 如果elementData不是Object类型数据(c.toArray可能返回的不是Object类型的数组所以加上下面的语句用于判断)if (elementData.getClass() != Object[].class)//将原来不是Object类型的elementData数组的内容,赋值给新的Object类型的elementData数组elementData = Arrays.copyOf(elementData, size, Object[].class);} else {// 其他情况,用空数组代替this.elementData = EMPTY_ELEMENTDATA;}}
​/*** 修改当前ArrayLIst集合大小为当前元素大小*/public void trimToSize() {modCount++;if (size < elementData.length) {elementData = (size == 0)? EMPTY_ELEMENTDATA: Arrays.copyOf(elementData, size);}}
​
​/*** 如有必要,增加此ArrayList实例的容量,以确保它至少能容纳元素的数量** @param minCapacity 所需的最小容量*/public void ensureCapacity(int minCapacity) {//如果是true,minExpand的值为0,如果是false,minExpand的值为10int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)// any size if not default element table? 0// larger than default for default empty table. It's already// supposed to be at default size.: DEFAULT_CAPACITY;//如果最小容量大于已有的最大容量if (minCapacity > minExpand) {ensureExplicitCapacity(minCapacity);}}
​//计算当前列表的容量private static int calculateCapacity(Object[] elementData, int minCapacity) {//DEFAULTCAPACITY_EMPTY_ELEMENTDATA默认无参构造方法中的空数组//这里指代的是:看看是否采用的是无参构造方法if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {//DEFAULT_CAPACITY:默认初始容量大小//返回 默认初始大小与 ArrayList中元素个数 中的最大的一个return Math.max(DEFAULT_CAPACITY, minCapacity);}//返回ArrayList元素个数return minCapacity;}
​//确保内部容量没有超出最大容量(如果超出则要扩容)private void ensureCapacityInternal(int minCapacity) {ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));}
​//判断是否需要扩容,看if判断// minCapacity指代的是当前列表的容量+1private void ensureExplicitCapacity(int minCapacity) {//modCount是一个受保护的成员变量,记录列表结构改变次数modCount++;
​// elementData指的是数组的大小,可以理解为列表最大大小//如果当前列表大小+1 > 列表最大大小,则进行扩容if (minCapacity - elementData.length > 0)grow(minCapacity);}
​/*** 要分配的最大数组大小*/private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
​
​/*** 扩容方法* 当需要添加更多元素,而当前容量不满足需求时,会调用此方法进行扩容。** @param minCapacity 所需的最小容量,确保 ArrayList 能够至少容纳这么多元素。*/private void grow(int minCapacity) {// 检查新的容量是否会溢出,如果会则直接扩容至Integer.MAX_VALUEint oldCapacity = elementData.length;// 使用位移运算符进行1.5倍扩容,这是一种快速的乘法计算方式,相当于 oldCapacity * 1.5int newCapacity = oldCapacity + (oldCapacity >> 1);
​// 如果计算出的新容量仍小于minCapacity,则直接使用minCapacity作为新容量if (newCapacity - minCapacity < 0) {newCapacity = minCapacity;}
​// 防止扩容后的容量超过ArrayList允许的最大容量(受限于Java数组的大小限制)//    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;if (newCapacity - MAX_ARRAY_SIZE > 0) {// 调用hugeCapacity来处理极大量级的扩容需求,确保不超过数组的最大可能容量newCapacity = hugeCapacity(minCapacity);}
​// 使用Arrays.copyOf方法来创建一个新数组,新数组的容量为newCapacity,并将原数组的元素复制到新数组中// 最后更新elementData引用指向这个更大的数组,完成扩容elementData = Arrays.copyOf(elementData, newCapacity);}
​/*** 用于处理极大容量的扩容需求。* 确保扩容后的容量不超过Integer.MAX_VALUE,并至少为minCapacity。** @param minCapacity 所需的最小容量* @return 调整后的、合理的扩容容量*/private static int hugeCapacity(int minCapacity) {// 如果minCapacity大于MAX_ARRAY_SIZE(即超过了数组的最大可能长度),则返回Integer.MAX_VALUE,// 否则返回MAX_ARRAY_SIZE以保证能容纳minCapacity个元素return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;}
​/*** 返回此列表中的元素数。*/public int size() {return size;}
​/*** 如果此列表不包含元素,则返回 true 。*/public boolean isEmpty() {//注意=和==的区别return size == 0;}
​/*** 如果此列表包含指定的元素,则返回true 。*/public boolean contains(Object o) {//indexOf()方法:返回此列表中指定元素的首次出现的索引,如果此列表不包含此元素,则为-1return indexOf(o) >= 0;}
​/*** 返回此列表中指定元素的首次出现的索引,如果此列表不包含此元素,则为-1*/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++)//equals()方法比较if (o.equals(elementData[i]))return i;}return -1;}
​/*** 返回此列表中指定元素的最后一次出现的索引,如果此列表不包含元素,则返回-1。.*/public int lastIndexOf(Object o) {if (o == null) {for (int i = size - 1; i >= 0; i--)if (elementData[i] == null)return i;} else {for (int i = size - 1; i >= 0; i--)if (o.equals(elementData[i]))return i;}return -1;}
​/*** 返回此ArrayList实例的浅拷贝。 (元素本身不被复制。)*/public Object clone() {try {ArrayList<?> v = (ArrayList<?>) super.clone();//Arrays.copyOf功能是实现数组的复制,返回复制后的数组。参数是被复制的数组和复制的长度v.elementData = Arrays.copyOf(elementData, size);v.modCount = 0;return v;} catch (CloneNotSupportedException e) {// 这不应该发生,因为我们是可以克隆的throw new InternalError(e);}}
​/*** 以正确的顺序(从第一个到最后一个元素)返回一个包含此列表中所有元素的数组。* 返回的数组将是“安全的”,因为该列表不保留对它的引用。 (换句话说,这个方法必须分配一个新的数组)。* 因此,调用者可以自由地修改返回的数组。 此方法充当基于阵列和基于集合的API之间的桥梁。*/public Object[] toArray() {return Arrays.copyOf(elementData, size);}
​/*** 以正确的顺序返回一个包含此列表中所有元素的数组(从第一个到最后一个元素);* 返回的数组的运行时类型是指定数组的运行时类型。 如果列表适合指定的数组,则返回其中。* 否则,将为指定数组的运行时类型和此列表的大小分配一个新数组。* 如果列表适用于指定的数组,其余空间(即数组的列表数量多于此元素),则紧跟在集合结束后的数组中的元素设置为null 。* (这仅在调用者知道列表不包含任何空元素的情况下才能确定列表的长度。)*/@SuppressWarnings("unchecked")public <T> T[] toArray(T[] a) {if (a.length < size)// 新建一个运行时类型的数组,但是ArrayList数组的内容return (T[]) Arrays.copyOf(elementData, size, a.getClass());//调用System提供的arraycopy()方法实现数组之间的复制System.arraycopy(elementData, 0, a, 0, size);if (a.length > size)a[size] = null;return a;}
​// Positional Access Operations
​@SuppressWarnings("unchecked")E elementData(int index) {return (E) elementData[index];}
​/*** 返回此列表中指定位置的元素。*/public E get(int index) {rangeCheck(index);
​return elementData(index);}
​/*** 用指定的元素替换此列表中指定位置的元素。*/public E set(int index, E element) {//对index进行界限检查rangeCheck(index);
​E oldValue = elementData(index);elementData[index] = element;//返回原来在这个位置的元素return oldValue;}
​/*** 将指定的元素追加到此列表的末尾。*/public boolean add(E e) {//size:ArrayList 所包含的元素个数ensureCapacityInternal(size + 1);  //增加modCountelementData[size++] = e;return true;}
​/*** 在此列表中的指定位置插入指定的元素。* 先调用 rangeCheckForAdd 对index进行界限检查;然后调用 ensureCapacityInternal 方法保证capacity足够大;* 再将从index开始之后的所有成员后移一个位置;将element插入index位置;最后size加1。*/public void add(int index, E element) {rangeCheckForAdd(index);
​ensureCapacityInternal(size + 1);  // Increments modCount!!//arraycopy()这个实现数组之间复制的方法一定要看一下,下面就用到了arraycopy()方法实现数组自己复制自己System.arraycopy(elementData, index, elementData, index + 1,size - index);elementData[index] = element;size++;}
​/*** 删除该列表中指定位置的元素。 将任何后续元素移动到左侧(从其索引中减去一个元素)。*/public E remove(int index) {rangeCheck(index);
​modCount++;E oldValue = elementData(index);
​int numMoved = size - index - 1;if (numMoved > 0)System.arraycopy(elementData, index + 1, elementData, index,numMoved);elementData[--size] = null; // clear to let GC do its work//从列表中删除的元素return oldValue;}
​/*** 从列表中删除指定元素的第一个出现(如果存在)。 如果列表不包含该元素,则它不会更改。* 返回true,如果此列表包含指定的元素*/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;}
​/** Private remove method that skips bounds checking and does not* return the value removed.*/private void fastRemove(int index) {modCount++;int numMoved = size - index - 1;if (numMoved > 0)System.arraycopy(elementData, index + 1, elementData, index,numMoved);elementData[--size] = null; // clear to let GC do its work}
​/*** 从列表中删除所有元素。*/public void clear() {modCount++;
​// 把数组中所有的元素的值设为nullfor (int i = 0; i < size; i++)elementData[i] = null;
​size = 0;}
​/*** 按指定集合的Iterator返回的顺序将指定集合中的所有元素追加到此列表的末尾。*/public boolean addAll(Collection<? extends E> c) {Object[] a = c.toArray();int numNew = a.length;ensureCapacityInternal(size + numNew);  // Increments modCountSystem.arraycopy(a, 0, elementData, size, numNew);size += numNew;return numNew != 0;}
​/*** 将指定集合中的所有元素插入到此列表中,从指定的位置开始。*/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;if (numMoved > 0)System.arraycopy(elementData, index, elementData, index + numNew,numMoved);
​System.arraycopy(a, 0, elementData, index, numNew);size += numNew;return numNew != 0;}
​/*** 从此列表中删除所有索引为fromIndex (含)和toIndex之间的元素。* 将任何后续元素移动到左侧(减少其索引)。*/protected void removeRange(int fromIndex, int toIndex) {modCount++;int numMoved = size - toIndex;System.arraycopy(elementData, toIndex, elementData, fromIndex,numMoved);
​// clear to let GC do its workint newSize = size - (toIndex - fromIndex);for (int i = newSize; i < size; i++) {elementData[i] = null;}size = newSize;}
​/*** 检查给定的索引是否在范围内。*/private void rangeCheck(int index) {if (index >= size)throw new IndexOutOfBoundsException(outOfBoundsMsg(index));}
​/*** add和addAll使用的rangeCheck的一个版本*/private void rangeCheckForAdd(int index) {if (index > size || index < 0)throw new IndexOutOfBoundsException(outOfBoundsMsg(index));}
​/*** 返回IndexOutOfBoundsException细节信息*/private String outOfBoundsMsg(int index) {return "Index: " + index + ", Size: " + size;}
​/*** 从此列表中删除指定集合中包含的所有元素。*/public boolean removeAll(Collection<?> c) {Objects.requireNonNull(c);//如果此列表被修改则返回truereturn batchRemove(c, false);}
​/*** 仅保留此列表中包含在指定集合中的元素。* 换句话说,从此列表中删除其中不包含在指定集合中的所有元素。*/public boolean retainAll(Collection<?> c) {Objects.requireNonNull(c);return batchRemove(c, true);}
​
​/*** 从列表中的指定位置开始,返回列表中的元素(按正确顺序)的列表迭代器。* 指定的索引表示初始调用将返回的第一个元素为next 。 初始调用previous将返回指定索引减1的元素。* 返回的列表迭代器是fail-fast 。*/public ListIterator<E> listIterator(int index) {if (index < 0 || index > size)throw new IndexOutOfBoundsException("Index: " + index);return new ListItr(index);}
​/*** 返回列表中的列表迭代器(按适当的顺序)。* 返回的列表迭代器是fail-fast 。*/public ListIterator<E> listIterator() {return new ListItr(0);}
​/*** 以正确的顺序返回该列表中的元素的迭代器。* 返回的迭代器是fail-fast 。*/public Iterator<E> iterator() {return new Itr();}

扩容讲解

这里通过对无参的构造方法进行讲解:

1、通过无参构造方法,将空Object数组赋值给底层存储对象列表的Object数组

    /*** 默认无参构造函数* DEFAULTCAPACITY_EMPTY_ELEMENTDATA 为0.初始化为10,也就是说初始其实是空数组 当添加第一个元素的时候数组容量才变成10*/public ArrayList() {this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;}

2、当要第一次进行插入元素的时候,进入add方法中

2.1、先使用ensureCapacityInternal方法,参数是当前列表元素容量+1

//add方法:
public boolean add(E e) {//size:ArrayList 所包含的元素个数ensureCapacityInternal(size + 1);  //增加modCountelementData[size++] = e;return true;
}

2.2、进入到ensureCapacityInternal方法中,先进行calculateCapacity方法

//确保内部容量没有超出最大容量(如果超出则要扩容)
private void ensureCapacityInternal(int minCapacity) {//elementData:存储了列表的对象数组//minCapacity:当前列表容量+1ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

2.3、进入到calculateCapacity方法中

  • 如果采用的是无参构造方法的,返回默认初始容量和数组容量之间的最大值。

  • 如果不是,则之间返回ArrayList元素个数

//计算当前列表的容量
private static int calculateCapacity(Object[] elementData, int minCapacity) {//DEFAULTCAPACITY_EMPTY_ELEMENTDATA默认无参构造方法中的空数组//这里指代的是:看看是否采用的是无参构造方法if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {//DEFAULT_CAPACITY:默认初始容量大小//返回 默认初始大小与 ArrayList中元素个数 中的最大的一个return Math.max(DEFAULT_CAPACITY, minCapacity);}//返回ArrayList元素个数return minCapacity;
}

2.4、执行完calculateCapacity后,得到的是当前列表的容量+1,然后在ensureCapacityInternal方法中,作为参数,传入到ensureExplicitCapacity方法中。判断是否需要进行扩容

//判断是否需要扩容,看if判断
//minCapacity指代的是当前列表的容量+1
private void ensureExplicitCapacity(int minCapacity) {//modCount是一个受保护的成员变量,记录列表结构改变次数modCount++;
​// elementData指的是数组的大小,可以理解为列表最大大小//如果当前列表大小+1 > 列表最大大小,则进行扩容if (minCapacity - elementData.length > 0)grow(minCapacity);
}

2.5、如果当前列表大小+1 大于 列表的最大容量,进入grow方法扩容

注:elementData.length代表的是最大的容量,而不是列表长度

/*** 当需要添加更多元素,而当前容量不满足需求时,会调用此方法进行扩容。** @param minCapacity 所需的最小容量,确保 ArrayList 能够至少容纳这么多元素。*/
private void grow(int minCapacity) {// 检查新的容量是否会溢出,如果会则直接扩容至Integer.MAX_VALUEint oldCapacity = elementData.length;// 使用位移运算符进行1.5倍扩容,这是一种快速的乘法计算方式,相当于 oldCapacity * 1.5int newCapacity = oldCapacity + (oldCapacity >> 1);// 如果计算出的新容量仍小于minCapacity,则直接使用minCapacity作为新容量if (newCapacity - minCapacity < 0) {newCapacity = minCapacity;}// 防止扩容后的容量超过ArrayList允许的最大容量(受限于Java数组的大小限制)//    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;if (newCapacity - MAX_ARRAY_SIZE > 0) {// 调用hugeCapacity来处理极大量级的扩容需求,确保不超过数组的最大可能容量newCapacity = hugeCapacity(minCapacity);}// 使用Arrays.copyOf方法来创建一个新数组,新数组的容量为newCapacity,并将原数组的元素复制到新数组中// 最后更新elementData引用指向这个更大的数组,完成扩容elementData = Arrays.copyOf(elementData, newCapacity);
}
​
/*** 用于处理极大容量的扩容需求。* 确保扩容后的容量不超过Integer.MAX_VALUE,并至少为minCapacity。** @param minCapacity 所需的最小容量* @return 调整后的、合理的扩容容量*/
private static int hugeCapacity(int minCapacity) {// 如果minCapacity大于MAX_ARRAY_SIZE(即超过了数组的最大可能长度),则返回Integer.MAX_VALUE,// 否则返回MAX_ARRAY_SIZE以保证能容纳minCapacity个元素return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}

2.6、我这个是Arrays类中的copeof方法源码

//elementData = Arrays.copyOf(elementData, newCapacity);
//original 原数组
//newCapacity 新的容量
​
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) {// 使用泛型和类型转换确保创建的新数组与指定类型兼容// 注意:这里使用了 SuppressWarnings 注解来抑制编译器的警告,因为显式类型转换是安全的@SuppressWarnings("unchecked")T[] copy; // 定义新数组变量,类型为T[]
​// 判断是否为Object类型的数组,如果是,则直接创建Object[]数组,否则根据newType创建指定类型的数组copy = ((Object)newType == (Object)Object[].class)? (T[]) new Object[newLength] // 如果目标类型是Object[],直接创建: (T[]) Array.newInstance(newType.getComponentType(), newLength); // 否则,反射创建指定类型的数组
​// 使用System.arraycopy方法将原数组内容复制到新数组中// 从原数组的起始位置(0)复制,到新数组的起始位置(0),复制的元素数量为原数组长度和新长度中较小的一个System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
​// 返回复制后的新数组return copy;
}

总结:ArrayList扩容时,采用的1.5倍扩容,并且采用的是复制Object数组进行扩容。

温馨提示:看完之后,建议按从add方法开始,进行模拟一遍,可以让思路更加清晰。

问题

1、为什么ArrayList采用1.5倍扩容?

  1. 减少扩容频率:通过每次扩容1.5倍,可以在添加多个元素时减少总体的扩容操作次数。相比每次只增加固定数量或按较小比例(如20%)扩容,1.5倍可以在元素数量增长时,较长时间内保持数组有足够的空间容纳新增元素,从而减少重新分配和复制数组的频次。

  2. 空间利用率与浪费平衡:如果每次扩容过多(比如总是翻倍),虽然减少了扩容操作的次数,但在元素数量增长缓慢时可能会导致较多的内存空间被闲置,造成浪费。而1.5倍的增长因子是一个折中方案,既不会过于频繁地执行扩容操作,又能在大多数情况下保持相对紧凑的内存使用。

  3. 性能考量:使用位移运算(oldCapacity >> 1)来计算新容量,这在计算机中是非常高效的,因为位移比乘法运算更快。1.5倍可以通过位移一位然后加原值的一半来高效实现((oldCapacity << 1) - oldCapacity 或者 oldCapacity + (oldCapacity >> 1)),这在某些JVM实现中可能比直接乘以1.5更高效。

  4. 历史因素:早期版本的Java中ArrayList扩容确实是直接翻倍(2倍),但经过性能测试和实践反馈,调整为1.5倍被认为是一个更好的平衡点。

2、ArrayList与LinkedList的区别

  1. 数据结构

    • ArrayList基于动态数组实现,意味着它在内部维护一个可以自动扩容的数组来存储元素。数组的特点是连续内存存储,因此支持随机访问,但插入和删除元素(尤其是数组中间的操作)可能需要移动大量元素,效率较低。

    • LinkedList基于链表实现,每个元素(节点)包括数据和指向下一个(和/或前一个)节点的引用。链表的内存可以是分散的,不连续,因此它不适合随机访问,但插入和删除操作非常高效,只需改变相邻节点的引用即可,无需移动元素。

  2. 访问速度

    • 对于随机访问(如getset操作),ArrayList由于其连续内存布局,性能通常优于LinkedList。通过索引访问数组元素的时间复杂度为O(1)。

    • 对于顺序访问(遍历),两者性能相近,但具体取决于实现细节和JVM的优化。

  3. 插入和删除速度

    • 在列表的开始或结束处添加或删除元素(addremove操作),两者性能接近,因为ArrayList可以通过调整索引来快速完成,而LinkedList仅需改变几个引用。

    • 在列表中间插入或删除元素时,LinkedList的性能通常优于ArrayList,因为它只需改变相邻节点的指针,而ArrayList可能需要移动大量元素。

  4. 内存使用

    • ArrayList由于维持连续内存,可能会有较大的内存浪费,尤其是在数组未满时。另外,数组需要的额外内存较少,因为它不需要存储每个元素的指针。

    • LinkedList每个节点都需要额外的内存来存储前后节点的引用,因此对于相同数量的元素,LinkedList通常占用更多的内存。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/web/21110.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

rust嵌入式开发之总结

我们用rust开发的新版产品刚刚交付&#xff0c;已经在海上安装测试完毕并顺利投产。终于松了口气&#xff0c;同时也有时间和精力来做个全面的总结了。 这个产品&#xff0c;目前差不多有三版&#xff1a; 第一个版本是用crt-thread写的&#xff0c;投产后出了一个内存泄露的…

521源码-源码论坛-宝塔面板操作日志是存放在哪里的? 如何删除部分日志记录

我们帮别人搭建或者登录了&#xff08;不是自己权属的宝塔面板&#xff09;&#xff0c;会留下登录及操作的日志&#xff0c;我们不想留下这些操作日志&#xff0c;可以通过下面的方法处理掉&#xff0c;以达到无痕迹访问操作的目的&#xff1a; 如图所示的面板操作日志&#…

Python-3.12.0文档解读-内置函数sum()详细说明+记忆策略+常用场景+巧妙用法+综合技巧

一个认为一切根源都是“自己不够强”的INTJ 个人主页&#xff1a;用哲学编程-CSDN博客专栏&#xff1a;每日一题——举一反三Python编程学习Python内置函数 Python-3.12.0文档解读 目录 详细说明 sum(iterable, /, start0) 参数&#xff1a; 返回值&#xff1a; 注意事…

骑砍2霸主MOD开发(10)-游戏大地图(MapScene)制作

一.MapScene中初始化NavMeshFaceID与TerrainType public TerrainType GetFaceTerrainType(PathFaceRecord navMeshFace){switch (navMeshFace.FaceGroupIndex){case 1:return TerrainType.Plain;case 2:return TerrainType.Desert;case 3:return TerrainType.Snow;case 4:retur…

算法优化:空间与时间复杂度的权衡

引言 在软件开发中&#xff0c;算法的性能至关重要。算法的性能通常通过其时间复杂度和空间复杂度来衡量。时间复杂度指的是算法执行时间与输入规模的关系&#xff0c;而空间复杂度则关注算法执行过程中所占用的存储空间。本文将探讨如何权衡这两者&#xff0c;以实现算法的最…

排序方法大汇总

以下所有排序方法均以排升序为例 一.插入排序 1.直接插入排序 1>方法介绍&#xff1a;假定前n个数据有序&#xff0c;将第n1个数据依次与前n个数据相比&#xff0c;若比第i个数据小且比第i-1个数据大则插入两者之间 2>时间复杂度&#xff1a;O(N^2) 空间复杂度&#…

【JS】对象转变成数组

1、Object.keys() 方法&#xff1a; 将对象的键转换为数组 const a { name: aa,age: 18 }; const arr Object.keys(a); console.log(arr); // 输出 [name, age] 2、Object.values() 方法&#xff1a; 将对象的值转换为数组 const a { name: aa,age: 18 }; const arr Obj…

BUUCTF中的密码题目解密

BUUCTF 1.MD5 题目名称就是MD5&#xff0c;这个题目肯定和md5密码有关&#xff0c;下载题目&#xff0c;打开后发现这确实是一个md5加密的密文 Md5在线解密网站&#xff1a;md5在线解密破解,md5解密加密 经过MD5在线解密网站解密后&#xff0c;获取到flag为&#xff1a;flag{…

域名主机服务器配置失败的原因和解决方法

域名主机服务器配置失败的原因可能涉及多个方面&#xff0c;包括域名设置、DNS配置、服务器设置、网络问题等。以下是一些常见的原因和相应的解决方案&#xff1a; 1. DNS配置错误 原因&#xff1a; 域名解析错误&#xff1a;域名没有正确指向服务器的IP地址。 DNS记录未更新&a…

网络编程TCP

White graces&#xff1a;个人主页 &#x1f649;专栏推荐:Java入门知识&#x1f649; &#x1f649; 内容推荐:Java网络编程(下)&#x1f649; &#x1f439;今日诗词: 壮士当唱大风哥, 宵小之徒能几何&#xff1f;&#x1f439; ⛳️点赞 ☀️收藏⭐️关注&#x1f4ac;卑微…

CentOS7单用户模式,救援模式操作记录

CentOS7单用户模式&#xff0c;救援模式操作记录 1. 单用户模式 单用户模式进入不需要密码&#xff0c;无网络连接&#xff0c;拥有root权限&#xff0c;禁止远程登陆。一般用于用于系统维护&#xff0c;例如忘记root密码后可以通过进入单用户模式进行重置。 开机启动&#…

数据结构 实验 1

题目一&#xff1a;用线性表实现文具店的货品管理问题 问题描述&#xff1a;在文具店的日常经营过程中&#xff0c;存在对各种文具的管理问题。当库存文具不足或缺货时&#xff0c;需要进货。日常销售时需要出库。当盘点货物时&#xff0c;需要查询货物信息。请根据这些要求编…

使用低代码系统的意义与价值主要体现在哪里?

使用低代码系统的意义与价值主要体现在以下几个方面&#xff0c;这些观点基于驰骋低代码设计者的专业洞察和行业经验&#xff1a; 快速原型创建&#xff1a; 低代码平台通过提供图形化界面和预构建的模块&#xff0c;极大地加速了系统原型的创建过程。这意味着企业能够更快地验…

60 关于 SegmentFault 的一些场景 (1)

前言 呵呵 此问题主要是来自于 帖子 月经结贴 -- 《Segmentation Fault in Linux》 这里主要也是 结合了作者的相关 case, 来做的一些 调试分享 当然 很多的情况还是 蛮有意思 本文主要问题如下 1. 访问可执行文件中的 只读数据 2. 访问不存在的虚拟地址 3. 访问内核地址…

嵌入式笔试面试刷题(day16)

文章目录 前言一、PWM波形的占空比计算公式是什么&#xff1f;二、ADC和DAC在嵌入式系统中的应用场景有哪些&#xff1f;三、watchdog定时器的作用及其在系统中的使用是什么&#xff1f;四、JTAG接口在嵌入式开发中的作用是什么&#xff1f;五、实时操作系统(RTOS)的任务调度策…

嵌入式工程师人生提质的十大成长型思维分享

大家好,作为一名嵌入式开发者,很多时候,需要考虑个人未来的发展,人生旅途复杂多变,时常面临各种各样的挑战。如何在这个复杂多变的社会中稳步向前,不断成长,成为每个人都应该思考的问题。实际上,思维方式的差异决定我们应对挑战的能力与成长的速度。 第一:寻找自我坐…

HNCTF2022 REVERSE

[HNCTF 2022 WEEK2]esy_flower 简单花指令 Nop掉 然后整段u c p然后就反汇编 可能反编译的不太对&#xff0c;&#xff0c;看了别人的wp就是ida反编译的有问题 #include<stdio.h> #include<string.h> int main() {int i,j;char ch[]"c~scvdzKCEoDEZ[^roDICU…

NumPy应用(二)

numpy高效的处理数据&#xff0c;提供数组的支持&#xff0c; python 默认没有数组。 pandas 、 scipy 、 matplotlib 都依赖 numpy 。 pandas主要用于数据挖掘&#xff0c;探索&#xff0c;分析 maiplotlib用于作图&#xff0c;可视化 scipy进行数值计算&#xff0c;如&…

微软远程连接工具:Microsoft Remote Desktop for Mac 中文版

Microsoft Remote Desktop 是一款由微软开发的远程桌面连接软件&#xff0c;它允许用户从远程地点连接到远程计算机或虚拟机&#xff0c;并在远程计算机上使用桌面应用程序和文件。 下载地址&#xff1a;https://www.macz.com/mac/5458.html?idOTI2NjQ5Jl8mMjcuMTg2LjEyNi4yMz…

C++进阶之AVL树+模拟实现

目录 目录 一、AVL树的基本概念 1.1 基本概念 二、AVL树的模拟实现 2.1 AVL树节点的定义 2.2 插入操作 2.3 旋转操作 2.4 具体实现 一、AVL树的基本概念 1.1 基本概念 二叉搜索树虽可以缩短查找的效率&#xff0c;但如果数据有序或接近有序二叉搜索树将退化为单支树&…