经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » Java » 查看文章
Java集合篇之深入解析ArrayList，这六问你答的上来吗？
来源：cnblogs　　作者：JavaBuild　　时间：2024/2/18 9:02:48　　对本文有异议

写在开头

开年第一篇，先祝各位新的一年身体健康，学业有成，事业有成哈，春节期间就是咔咔乱吃，咔咔乱玩，把学习都抛一边子去了，已经9天没有学习了，深深的懊悔，从今天开始，2024年的学习正式开启，一起给我猛冲！！！
书接上回，我们开启了Java集合部分的学习，今天我们就来看一下List，其中它的核心有两个，一个ArrayList，一个LinkedList，而ArrayList的使用频率在集合中至少排第二，可以和HashMap掰掰手腕子！
盘点Java集合（容器）概览，Collection和Map在开发中谁用的最多？

问一：ArrayList和Array的区别？

Array(数组)是一种引用类型，主要作用是用来存储数据，即可存储基本数据类型也可存储对象，但在定义一个数组时需要注意：必须指定数组的数据类型及数组长度，即数组中存放的元素个数固定并且类型相同。故我们也可以将Array称作静态数组。

【代码示例1】

  1. //数组的几种声明方式
  2. int[] array = new int[3];
  3. int array [] = new int[3];
  4. int[] array = {1, 2, 3};
  5. int[] array = new int[]{1, 2, 3};

而ArrayList的底层是通过动态数组实现，长度动态可变，会自动扩容。不使用泛型的时候，可以添加不同类型元素。

【代码示例2】

  1. List list = new ArrayList(4);
  2. list.add(1);
  3. list.add("1");
  4. list.add(new Double("1.1"));
  5. list.add("Happy New Year");
  6. for (Object o : list) {
  7.     System.out.println(o);
  8. }

区别总结：

  1. 1、ArrayList会根据实际存储的元素动态地扩容或缩容，而 Array 被创建之后就不能改变它的长度了。
  2. 2、ArrayList 允许你使用泛型来确保类型安全，Array 则不可以。
  3. 3、ArrayList 中只能存储对象。对于基本类型数据，需要使用其对应的包装类（如 Integer、Double 等）。Array 可以直接存储基本类型数据，也可以存储对象。
  4. 4、ArrayList 支持插入、删除、遍历等常见操作，并且提供了丰富的 API 操作方法，比如 add()、remove()等。Array 只是一个固定长度的数组，只能按照下标访问其中的元素，不具备动态添加、删除元素的能力。
  5. 5、ArrayList创建时不需要指定大小，而Array创建时必须指定大小。

问二：ArrayList和Vector的区别？

二者都是List的实现类，底层都通过object[]数组实现，但Vector是早起JDK支持的集合类，目前几乎全部ArrayList替代，二者有着相似的增删改查功能，但不同的是，Vector的方法都是同步的，可以保证线程安全，而ArrayList则不是，因此，ArrayList相较于Vector拥有良好的性能；两者的扩容也存在着不同，默认初始化容量都是10，Vector 扩容默认会翻倍，可指定扩容的大小；ArrayList只增加 50%

问三：ArrayList和LinkedList的区别？

作为List的另外一个子类，LinkedList的出镜率虽然没有ArrayList高，但总有一些场景会用到，我们还是要学一下的哈。
LinkedList的底层是用过双向链表实现，我们简单的感受一下它的使用，后面会针对LinkedList专门总结一篇博客。

【代码示例3】

  1.   // 创建LinkedList集合
  2.   LinkedList link = new LinkedList();
  3.   // 1、添加元素
  4.   link.add("happy");
  5.   link.add("new");
  6.   link.offer("year"); // 向集合尾部追加元素
  7.   link.push("javabuild"); // 向集合头部添加元素
  8.   System.out.println(link); // 输出集合中的元素
  9.   // 2、获取元素
  10.   Object object = link.peek(); //获取集合第一个元素
  11.   System.out.println(object); // 输出集合中的元素
  12.   // 3、删除元素
  13.   link.removeFirst(); // 删除集合第一个元素
  14.   link.pollLast(); // 删除集合最后一个元素
  15.   System.out.println(link);

【输出】

  1. [javabuild, happy, new, year]
  2. javabuild
  3. [happy, new]

区别总结：

  1. ArrayList 和 LinkedList 都是不同步的，也就是不保证线程安全；
  2. ArrayList 底层使用的是 Object 数组；LinkedList 底层使用的是双向链表数据结构；
  3. LinkedList 不支持高效的随机元素访问，而 ArrayList（实现了 RandomAccess 接口） 支持。
  4. ArrayList存在扩容问题，LinkedList不存在，直接放在集合尾部，修改指针即可；

问四：知道ArrayList的扩容机制吗？

要想充分的了解ArrayList的扩容，必须静心阅读其底层源码，JDK1.8源码如下：

  1. public class ArrayList<E> extends AbstractList<E>
  2.         implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
  3.     private static final long serialVersionUID = 8683452581122892189L;
  5.     /**
  6.      * 默认初始容量大小
  7.      */
  8.     private static final int DEFAULT_CAPACITY = 10;
  10.     /**
  11.      * 空数组（用于空实例）。
  12.      */
  13.     private static final Object[] EMPTY_ELEMENTDATA = {};
  15.     //用于默认大小空实例的共享空数组实例。
  16.     //我们把它从EMPTY_ELEMENTDATA数组中区分出来，以知道在添加第一个元素时容量需要增加多少。
  17.     private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
  19.     /**
  20.      * 保存ArrayList数据的数组
  21.      */
  22.     transient Object[] elementData; // non-private to simplify nested class access
  24.     /**
  25.      * ArrayList 所包含的元素个数
  26.      */
  27.     private int size;
  29.     /**
  30.      * 带初始容量参数的构造函数（用户可以在创建ArrayList对象时自己指定集合的初始大小）
  31.      */
  32.     public ArrayList(int initialCapacity) {
  33.         if (initialCapacity > 0) {
  34.             //如果传入的参数大于0，创建initialCapacity大小的数组
  35.             this.elementData = new Object[initialCapacity];
  36.         } else if (initialCapacity == 0) {
  37.             //如果传入的参数等于0，创建空数组
  38.             this.elementData = EMPTY_ELEMENTDATA;
  39.         } else {
  40.             //其他情况，抛出异常
  41.             throw new IllegalArgumentException("Illegal Capacity: " +
  42.                     initialCapacity);
  43.         }
  44.     }
  46.     /**
  47.      * 默认无参构造函数
  48.      * DEFAULTCAPACITY_EMPTY_ELEMENTDATA 为0.初始化为10，也就是说初始其实是空数组 当添加第一个元素的时候数组容量才变成10
  49.      */
  50.     public ArrayList() {
  51.         this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
  52.     }
  54.     /**
  55.      * 构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。
  56.      */
  57.     public ArrayList(Collection<? extends E> c) {
  58.         //将指定集合转换为数组
  59.         elementData = c.toArray();
  60.         //如果elementData数组的长度不为0
  61.         if ((size = elementData.length) != 0) {
  62.             // 如果elementData不是Object类型数据（c.toArray可能返回的不是Object类型的数组所以加上下面的语句用于判断）
  63.             if (elementData.getClass() != Object[].class)
  64.                 //将原来不是Object类型的elementData数组的内容，赋值给新的Object类型的elementData数组
  65.                 elementData = Arrays.copyOf(elementData, size, Object[].class);
  66.         } else {
  67.             // 其他情况，用空数组代替
  68.             this.elementData = EMPTY_ELEMENTDATA;
  69.         }
  70.     }
  72.     /**
  73.      * 修改这个ArrayList实例的容量是列表的当前大小。 应用程序可以使用此操作来最小化ArrayList实例的存储。
  74.      */
  75.     public void trimToSize() {
  76.         modCount++;
  77.         if (size < elementData.length) {
  78.             elementData = (size == 0)
  79.                     ? EMPTY_ELEMENTDATA
  80.                     : Arrays.copyOf(elementData, size);
  81.         }
  82.     }
  83. //下面是ArrayList的扩容机制
  84. //ArrayList的扩容机制提高了性能，如果每次只扩充一个，
  85. //那么频繁的插入会导致频繁的拷贝，降低性能，而ArrayList的扩容机制避免了这种情况。
  87.     /**
  88.      * 如有必要，增加此ArrayList实例的容量，以确保它至少能容纳元素的数量
  89.      *
  90.      * @param minCapacity 所需的最小容量
  91.      */
  92.     public void ensureCapacity(int minCapacity) {
  93.         //如果是true，minExpand的值为0，如果是false,minExpand的值为10
  94.         int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
  95.                 // any size if not default element table
  96.                 ? 0
  97.                 // larger than default for default empty table. It's already
  98.                 // supposed to be at default size.
  99.                 : DEFAULT_CAPACITY;
  100.         //如果最小容量大于已有的最大容量
  101.         if (minCapacity > minExpand) {
  102.             ensureExplicitCapacity(minCapacity);
  103.         }
  104.     }
  106.     // 根据给定的最小容量和当前数组元素来计算所需容量。
  107.     private static int calculateCapacity(Object[] elementData, int minCapacity) {
  108.         // 如果当前数组元素为空数组（初始情况），返回默认容量和最小容量中的较大值作为所需容量
  109.         if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
  110.             return Math.max(DEFAULT_CAPACITY, minCapacity);
  111.         }
  112.         // 否则直接返回最小容量
  113.         return minCapacity;
  114.     }
  116.     // 确保内部容量达到指定的最小容量。
  117.     private void ensureCapacityInternal(int minCapacity) {
  118.         ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
  119.     }
  121.     //判断是否需要扩容
  122.     private void ensureExplicitCapacity(int minCapacity) {
  123.         modCount++;
  124.         // overflow-conscious code
  125.         if (minCapacity - elementData.length > 0)
  126.             //调用grow方法进行扩容，调用此方法代表已经开始扩容了
  127.             grow(minCapacity);
  128.     }
  130.     /**
  131.      * 要分配的最大数组大小
  132.      */
  133.     private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
  135.     /**
  136.      * ArrayList扩容的核心方法。
  137.      */
  138.     private void grow(int minCapacity) {
  139.         // oldCapacity为旧容量，newCapacity为新容量
  140.         int oldCapacity = elementData.length;
  141.         //将oldCapacity 右移一位，其效果相当于oldCapacity /2，
  142.         //我们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量的1.5倍，
  143.         int newCapacity = oldCapacity + (oldCapacity >> 1);
  144.         //然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容量当作数组的新容量，
  145.         if (newCapacity - minCapacity < 0)
  146.             newCapacity = minCapacity;
  147.         //再检查新容量是否超出了ArrayList所定义的最大容量，
  148.         //若超出了，则调用hugeCapacity()来比较minCapacity和 MAX_ARRAY_SIZE，
  149.         //如果minCapacity大于MAX_ARRAY_SIZE，则新容量则为Integer.MAX_VALUE，否则，新容量大小则为 MAX_ARRAY_SIZE。
  150.         if (newCapacity - MAX_ARRAY_SIZE > 0)
  151.             newCapacity = hugeCapacity(minCapacity);
  152.         // minCapacity is usually close to size, so this is a win:
  153.         elementData = Arrays.copyOf(elementData, newCapacity);
  154.     }
  156.     //比较minCapacity和 MAX_ARRAY_SIZE
  157.     private static int hugeCapacity(int minCapacity) {
  158.         if (minCapacity < 0) // overflow
  159.             throw new OutOfMemoryError();
  160.         return (minCapacity > MAX_ARRAY_SIZE) ?
  161.                 Integer.MAX_VALUE :
  162.                 MAX_ARRAY_SIZE;
  163.     }
  165.     /**
  166.      * 返回此列表中的元素数。
  167.      */
  168.     public int size() {
  169.         return size;
  170.     }
  172.     /**
  173.      * 如果此列表不包含元素，则返回 true 。
  174.      */
  175.     public boolean isEmpty() {
  176.         //注意=和==的区别
  177.         return size == 0;
  178.     }
  180.     /**
  181.      * 如果此列表包含指定的元素，则返回true 。
  182.      */
  183.     public boolean contains(Object o) {
  184.         //indexOf()方法：返回此列表中指定元素的首次出现的索引，如果此列表不包含此元素，则为-1
  185.         return indexOf(o) >= 0;
  186.     }
  188.     /**
  189.      * 返回此列表中指定元素的首次出现的索引，如果此列表不包含此元素，则为-1
  190.      */
  191.     public int indexOf(Object o) {
  192.         if (o == null) {
  193.             for (int i = 0; i < size; i++)
  194.                 if (elementData[i] == null)
  195.                     return i;
  196.         } else {
  197.             for (int i = 0; i < size; i++)
  198.                 //equals()方法比较
  199.                 if (o.equals(elementData[i]))
  200.                     return i;
  201.         }
  202.         return -1;
  203.     }
  205.     /**
  206.      * 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。.
  207.      */
  208.     public int lastIndexOf(Object o) {
  209.         if (o == null) {
  210.             for (int i = size - 1; i >= 0; i--)
  211.                 if (elementData[i] == null)
  212.                     return i;
  213.         } else {
  214.             for (int i = size - 1; i >= 0; i--)
  215.                 if (o.equals(elementData[i]))
  216.                     return i;
  217.         }
  218.         return -1;
  219.     }
  221.     /**
  222.      * 返回此ArrayList实例的浅拷贝。 （元素本身不被复制。）
  223.      */
  224.     public Object clone() {
  225.         try {
  226.             ArrayList<?> v = (ArrayList<?>) super.clone();
  227.             //Arrays.copyOf功能是实现数组的复制，返回复制后的数组。参数是被复制的数组和复制的长度
  228.             v.elementData = Arrays.copyOf(elementData, size);
  229.             v.modCount = 0;
  230.             return v;
  231.         } catch (CloneNotSupportedException e) {
  232.             // 这不应该发生，因为我们是可以克隆的
  233.             throw new InternalError(e);
  234.         }
  235.     }
  237.     /**
  238.      * 以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。
  239.      * 返回的数组将是“安全的”，因为该列表不保留对它的引用。 （换句话说，这个方法必须分配一个新的数组）。
  240.      * 因此，调用者可以自由地修改返回的数组。 此方法充当基于阵列和基于集合的API之间的桥梁。
  241.      */
  242.     public Object[] toArray() {
  243.         return Arrays.copyOf(elementData, size);
  244.     }
  246.     /**
  247.      * 以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）;
  248.      * 返回的数组的运行时类型是指定数组的运行时类型。 如果列表适合指定的数组，则返回其中。
  249.      * 否则，将为指定数组的运行时类型和此列表的大小分配一个新数组。
  250.      * 如果列表适用于指定的数组，其余空间（即数组的列表数量多于此元素），则紧跟在集合结束后的数组中的元素设置为null 。
  251.      * （这仅在调用者知道列表不包含任何空元素的情况下才能确定列表的长度。）
  252.      */
  253.     @SuppressWarnings("unchecked")
  254.     public <T> T[] toArray(T[] a) {
  255.         if (a.length < size)
  256.             // 新建一个运行时类型的数组，但是ArrayList数组的内容
  257.             return (T[]) Arrays.copyOf(elementData, size, a.getClass());
  258.         //调用System提供的arraycopy()方法实现数组之间的复制
  259.         System.arraycopy(elementData, 0, a, 0, size);
  260.         if (a.length > size)
  261.             a[size] = null;
  262.         return a;
  263.     }
  265.     // Positional Access Operations
  267.     @SuppressWarnings("unchecked")
  268.     E elementData(int index) {
  269.         return (E) elementData[index];
  270.     }
  272.     /**
  273.      * 返回此列表中指定位置的元素。
  274.      */
  275.     public E get(int index) {
  276.         rangeCheck(index);
  278.         return elementData(index);
  279.     }
  281.     /**
  282.      * 用指定的元素替换此列表中指定位置的元素。
  283.      */
  284.     public E set(int index, E element) {
  285.         //对index进行界限检查
  286.         rangeCheck(index);
  288.         E oldValue = elementData(index);
  289.         elementData[index] = element;
  290.         //返回原来在这个位置的元素
  291.         return oldValue;
  292.     }
  294.     /**
  295.      * 将指定的元素追加到此列表的末尾。
  296.      */
  297.     public boolean add(E e) {
  298.         ensureCapacityInternal(size + 1);  // Increments modCount!!
  299.         //这里看到ArrayList添加元素的实质就相当于为数组赋值
  300.         elementData[size++] = e;
  301.         return true;
  302.     }
  304.     /**
  305.      * 在此列表中的指定位置插入指定的元素。
  306.      * 先调用 rangeCheckForAdd 对index进行界限检查；然后调用 ensureCapacityInternal 方法保证capacity足够大；
  307.      * 再将从index开始之后的所有成员后移一个位置；将element插入index位置；最后size加1。
  308.      */
  309.     public void add(int index, E element) {
  310.         rangeCheckForAdd(index);
  312.         ensureCapacityInternal(size + 1);  // Increments modCount!!
  313.         //arraycopy()这个实现数组之间复制的方法一定要看一下，下面就用到了arraycopy()方法实现数组自己复制自己
  314.         System.arraycopy(elementData, index, elementData, index + 1,
  315.                 size - index);
  316.         elementData[index] = element;
  317.         size++;
  318.     }
  320.     /**
  321.      * 删除该列表中指定位置的元素。 将任何后续元素移动到左侧（从其索引中减去一个元素）。
  322.      */
  323.     public E remove(int index) {
  324.         rangeCheck(index);
  326.         modCount++;
  327.         E oldValue = elementData(index);
  329.         int numMoved = size - index - 1;
  330.         if (numMoved > 0)
  331.             System.arraycopy(elementData, index + 1, elementData, index,
  332.                     numMoved);
  333.         elementData[--size] = null; // clear to let GC do its work
  334.         //从列表中删除的元素
  335.         return oldValue;
  336.     }
  338.     /**
  339.      * 从列表中删除指定元素的第一个出现（如果存在）。 如果列表不包含该元素，则它不会更改。
  340.      * 返回true，如果此列表包含指定的元素
  341.      */
  342.     public boolean remove(Object o) {
  343.         if (o == null) {
  344.             for (int index = 0; index < size; index++)
  345.                 if (elementData[index] == null) {
  346.                     fastRemove(index);
  347.                     return true;
  348.                 }
  349.         } else {
  350.             for (int index = 0; index < size; index++)
  351.                 if (o.equals(elementData[index])) {
  352.                     fastRemove(index);
  353.                     return true;
  354.                 }
  355.         }
  356.         return false;
  357.     }
  359.     /*
  360.      * Private remove method that skips bounds checking and does not
  361.      * return the value removed.
  362.      */
  363.     private void fastRemove(int index) {
  364.         modCount++;
  365.         int numMoved = size - index - 1;
  366.         if (numMoved > 0)
  367.             System.arraycopy(elementData, index + 1, elementData, index,
  368.                     numMoved);
  369.         elementData[--size] = null; // clear to let GC do its work
  370.     }
  372.     /**
  373.      * 从列表中删除所有元素。
  374.      */
  375.     public void clear() {
  376.         modCount++;
  378.         // 把数组中所有的元素的值设为null
  379.         for (int i = 0; i < size; i++)
  380.             elementData[i] = null;
  382.         size = 0;
  383.     }
  385.     /**
  386.      * 按指定集合的Iterator返回的顺序将指定集合中的所有元素追加到此列表的末尾。
  387.      */
  388.     public boolean addAll(Collection<? extends E> c) {
  389.         Object[] a = c.toArray();
  390.         int numNew = a.length;
  391.         ensureCapacityInternal(size + numNew);  // Increments modCount
  392.         System.arraycopy(a, 0, elementData, size, numNew);
  393.         size += numNew;
  394.         return numNew != 0;
  395.     }
  397.     /**
  398.      * 将指定集合中的所有元素插入到此列表中，从指定的位置开始。
  399.      */
  400.     public boolean addAll(int index, Collection<? extends E> c) {
  401.         rangeCheckForAdd(index);
  403.         Object[] a = c.toArray();
  404.         int numNew = a.length;
  405.         ensureCapacityInternal(size + numNew);  // Increments modCount
  407.         int numMoved = size - index;
  408.         if (numMoved > 0)
  409.             System.arraycopy(elementData, index, elementData, index + numNew,
  410.                     numMoved);
  412.         System.arraycopy(a, 0, elementData, index, numNew);
  413.         size += numNew;
  414.         return numNew != 0;
  415.     }
  417.     /**
  418.      * 从此列表中删除所有索引为fromIndex （含）和toIndex之间的元素。
  419.      * 将任何后续元素移动到左侧（减少其索引）。
  420.      */
  421.     protected void removeRange(int fromIndex, int toIndex) {
  422.         modCount++;
  423.         int numMoved = size - toIndex;
  424.         System.arraycopy(elementData, toIndex, elementData, fromIndex,
  425.                 numMoved);
  427.         // clear to let GC do its work
  428.         int newSize = size - (toIndex - fromIndex);
  429.         for (int i = newSize; i < size; i++) {
  430.             elementData[i] = null;
  431.         }
  432.         size = newSize;
  433.     }
  435.     /**
  436.      * 检查给定的索引是否在范围内。
  437.      */
  438.     private void rangeCheck(int index) {
  439.         if (index >= size)
  440.             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
  441.     }
  443.     /**
  444.      * add和addAll使用的rangeCheck的一个版本
  445.      */
  446.     private void rangeCheckForAdd(int index) {
  447.         if (index > size || index < 0)
  448.             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
  449.     }
  451.     /**
  452.      * 返回IndexOutOfBoundsException细节信息
  453.      */
  454.     private String outOfBoundsMsg(int index) {
  455.         return "Index: " + index + ", Size: " + size;
  456.     }
  458.     /**
  459.      * 从此列表中删除指定集合中包含的所有元素。
  460.      */
  461.     public boolean removeAll(Collection<?> c) {
  462.         Objects.requireNonNull(c);
  463.         //如果此列表被修改则返回true
  464.         return batchRemove(c, false);
  465.     }
  467.     /**
  468.      * 仅保留此列表中包含在指定集合中的元素。
  469.      * 换句话说，从此列表中删除其中不包含在指定集合中的所有元素。
  470.      */
  471.     public boolean retainAll(Collection<?> c) {
  472.         Objects.requireNonNull(c);
  473.         return batchRemove(c, true);
  474.     }
  477.     /**
  478.      * 从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。
  479.      * 指定的索引表示初始调用将返回的第一个元素为next 。 初始调用previous将返回指定索引减1的元素。
  480.      * 返回的列表迭代器是fail-fast 。
  481.      */
  482.     public ListIterator<E> listIterator(int index) {
  483.         if (index < 0 || index > size)
  484.             throw new IndexOutOfBoundsException("Index: " + index);
  485.         return new ListItr(index);
  486.     }
  488.     /**
  489.      * 返回列表中的列表迭代器（按适当的顺序）。
  490.      * 返回的列表迭代器是fail-fast 。
  491.      */
  492.     public ListIterator<E> listIterator() {
  493.         return new ListItr(0);
  494.     }
  496.     /**
  497.      * 以正确的顺序返回该列表中的元素的迭代器。
  498.      * 返回的迭代器是fail-fast 。
  499.      */
  500.     public Iterator<E> iterator() {
  501.         return new Itr();
  502.     }

通过阅读源码和其中注释，我们不难得出这样的结论：ArrayList的无参构造默认初始化长度为10，在添加元素大于初始容量后，会触发扩容，而数组的扩容是将原数组中的元素拷贝到一个新数组中，将数组容量增加为原数组1.5倍。

问五：ArrayList增删改查的时间复杂度？

  • 查询时间复杂度： O(1)，因为 ArrayList 内部使用数组来存储元素，所以可以直接根据索引来访问元素。
  • 增加时间复杂度：添加一个元素（调用 add() 方法时）的时间复杂度最好情况为 O(1)，最坏情况为 O(n)。
  • 删除时间复杂度：删除一个元素（调用 remove(Object) 方法时）的时间复杂度最好情况 O(1)，最坏情况 O(n)。
  • 修改时间复杂度：修改一个元素（调用 set()方法时）与查询操作类似，可以直接根据索引来访问元素，时间复杂度为 O(1)。

注：最好和最快情况分别是在列别尾部操作和头部或中间操作的差距。

问六：Vector、ArrayList、LinkedList 的存储性能和特性？

  1. 1、ArrayList 和 Vector 都是使用数组存储数据
  2. 2、ArrayList 允许直接按序号索引元素
  3. 3、ArrayList 插入元素涉及数组扩容、元素移动等内存操作
  4. 4、ArrayList 根据下标找元素快，存在扩容的情况下插入慢
  5. 5、Vector 对元素的操作，使用了 synchronized 方法，性能比 ArrayList 差
  6. 6、Vector 属于遗留容器，早期的 JDK 中使用的容器
  7. 7、LinkedList 使用双向链表存储元素
  8. 8、LinkedList 按序号查找元素，需要进行前向或后向遍历，所以按下标查找元素，效率较低
  9. 9、LinkedList 非线程安全
  10. 10、LinkedList 使用的链式存储方式与数组的连续存储方式相比，对内存的利用率更高
  11. 11、LinkedList 插入数据时只需要移动指针即可，所以插入速度较快

结尾彩蛋

如果本篇博客对您有一定的帮助，大家记得留言+点赞+收藏呀。原创不易，转载请联系Build哥！

原文链接：https://www.cnblogs.com/JavaBuild/p/18017845

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Java热门文章

  • 【IDEA】Application context not configured for this file
  • [IDEA] chapter_reader - idea看小说插件 idea阅读插件 idea摸鱼插件
  • thrift常见异常及原因分析
  • Java 调用 PaddleDetection 模型
  • JVM 详解，大白话带你认识 JVM
  • spring-boot-2.0.3不一样系列之番外篇 - @Configuration、Condition与@Conditional
  • Java Comparator.comparing比较导致空指针异常的解决
  • Java使用EasyExcel进行单元格合并的问题详解
  • 死磕 java集合之ArrayBlockingQueue源码分析
  • Java基础之集合Set详解

    • Java推荐文章

  • 面试场景题：一次关于线程池使用场景的讨论。
  • 前端黑科技：使用 JavaScript 实现网页扫码功能
  • 聊一聊 Netty 数据搬运工 ByteBuf 体系的设计与实现
  • 简单设计一个JAVA并行处理工具类
  • 【杂谈】JPA乐观锁改悲观锁遇到的一些问题与思考
  • 认识netty的基本组件
  • Jenkins如何使用CrumbIssuer防御CSRF攻击
  • 如何平稳地从nacos迁移到r-nacos？
  • 线程池遇到父子任务，有大坑，要注意！
  • Java JVM——12. 垃圾回收理论概述

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号