ArrayList 源码深度解析

最新推荐文章于 2023-07-13 21:19:56 发布
最新推荐文章于 2023-07-13 21:19:56 发布
阅读量131 收藏
点赞数
分类专栏： # Java8之集合源码分析
原文链接：https://blog.csdn.net/qq_26803795/article/details/104559703
版权

ArrayList 源码深度解析

1、为什么要用ArrayList?ArrayList是什么？

      我们用数组来存放一组类型相同的变量,数组是一种顺序存储的线性表，所有元素的内存地址都是连续的，但它有一个致命的缺点：无法动态修改容量，ArrayList解决了这个问题，它使用Object数组存储数据，当容量不够时可以动态扩容。

2、重新认识ArrayList

2.1、什么是ArrayList？

ArrayList是基于数组实现的List类，封装了一个动态再分配的Object数组，以达到可以动态增长和缩减的索引序列。

2.2、长啥样？

在这里插入图片描述
如图，是一个长度为6，存储了6个6的数组，下标（index）从0开始，数组（elementData）表示存储的数据本身。

2.3、有哪些基本概念？

  1. index 表示数组下标；
  2. elementData 表示数组本身；
  3. DEFAULT_CAPACITY 表示数组初始大小，默认是10；
  4. size 表示当前数组的大小，int类型，未使用volatile修饰，非线程安全；
  5. modCount 表示当前数组被修改的版本的次数，也就是说当数组结构有变动，就会+1。

3、知其所以然----撸源码

3.1、从整个ArrayList.java的类注释开始入手

简单翻译总结如下：
1、ArrayList允许put null值，并且会自动扩容；
2、 size，isEmpty，get，set，Iterator和listIterator方法的时间复杂度是O(1)，add方法的复杂度根据添加元素的多少而不同，添加n个元素，时间复杂度O(n)；
3、 非线程安全，因此在多线程情况下，为了线程安全推荐使用（List<String> list = Collections.synchronizedList(new ArrayList<>());或List<String> list = new CopyOnWriteArrayList<>();）；
4、支持增强for循环，但需要注意的是，由于非线程安全，所以在使用迭代器迭代过程中，如果数组大小被改变，会快速失败，并抛出异常。

3.2、 初始化

三种初始化方式，源码分析

3.2.1、无参数初始化
//  无参数构造器，默认是空数组
public ArrayList() {
 this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
3.2.2、指定初始容量大小的初始化
// 构造一个具有指定初始容量的空列表
public ArrayList(int initialCapacity) {
	if (initialCapacity > 0) {
	 this.elementData = new Object[initialCapacity];
	} else if (initialCapacity == 0) {
	 this.elementData = EMPTY_ELEMENTDATA;
	} else {
	 throw new IllegalArgumentException("Illegal Capacity: "+
	                              		 initialCapacity);
	}
}
3.2.3、指定初始数据初始化
//指定初始数据初始化
public ArrayList(Collection<? extends E> c) {
	//elementData 是保存数组的容器，默认为 null
	elementData = c.toArray();
	//如果给定的集合（c）数据有值，则进行拷贝赋值操作
	if ((size = elementData.length) != 0) {
	  // c.toArray might (incorrectly) not return Object[] (see 6260652)
	  //如果集合元素类型不是 Object 类型，才开始拷贝，否则不执行
	  if (elementData.getClass() != Object[].class) {
		elementData = Arrays.copyOf(elementData, size, Object[].class);
	  }
	} else {
	  // 给定集合（c）无值，则默认空数组
	  this.elementData = EMPTY_ELEMENTDATA;
	}
}
3.2.4、特别注意
  • 使用无参数构造器初始化时，默认容量时0，而不是传统印象里的10，只有接着对其进行add时才会变成10；
  • 通过观察ArrayList的无参构造器，会发现当它进行初始化时，默认大小是空数组；
  • 可以发现在指定初始数据初始化这种方式里，有一个see 6260652的注释，这是一个1.8版本的bug，在1.9版本的到了解决。解释是（toArray方法可能不会返回Object数组），也就是说当我们有一个ArrayList，里面的元素不是Object类型，比如是String，然后当我们调用toArray方法，得到一个Object数组后，再往这个String类型的Object数组赋值时，就会触发这个BUG，报错。官方查看文档地址：https://bugs.java.com/bugdatabase/view_bug.do?bug_id=6260652

3.3、新增元素及扩容

3.3.1、先来看下新增元素核心源码
public boolean add(E e) {
	//确保数组大小足够，不够需要扩容
	ensureCapacityInternal(size + 1);  // Increments modCount!!
	//直接赋值，非线程安全
	elementData[size++] = e;
	return true;
}

通过源码，我们可以知道新增就是往数组中添加元素，主要分为两步：

  • 判断是否需要扩容，如需要就执行扩容操作
  • 直接赋值（非线程安全）
3.3.2、接着看下扩容源码的实现
private void ensureCapacityInternal(int minCapacity) {
 //如果是空数组，就从最小容量和默认容量10之间取最大值
 //反之如果初始化时给定了初始值，就按照给定的大小为准，不走if逻辑
 if(elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
  minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
 }
 //确保容积足够
 ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
 //记录数组被修改
 modCount++;
 // 如果我们希望的最小容量大于目前数组的长度，那么就扩容
 if (minCapacity - elementData.length > 0)
    grow(minCapacity);
}
//扩容，最后把现有数据拷贝到新的数组里面去
private void grow(int minCapacity) {
 // overflow-conscious code
 int oldCapacity = elementData.length;
 // oldCapacity >> 1 右移运算符，是把 oldCapacity / 2 的意思
 int newCapacity = oldCapacity + (oldCapacity >> 1);
 // 如果扩容后的新的容量值 < 我们的期望容量值，那么就取我们的期望容量值
// 也就是扩充的容量至少要满足我们的期望，宁多勿少
 if (newCapacity - minCapacity < 0)
  newCapacity = minCapacity;
// 如果扩容后的值 > jvm 所能分配的数组的最大值，那么就取Integer 的最大值
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);
}
 //获取Integer的最大值
 private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
  throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
	   Integer.MAX_VALUE :
	   MAX_ARRAY_SIZE;
}
3.3.3、扩容的本质就是数组的拷贝

我们通过源码可以发现，扩容的核心是一行代码：elementData = Arrays.copyOf(elementData, newCapacity);扩容会首先创建一个符合要求容量的新数组，然后把老数组的数据拷贝过去；我们一层层的点进去，会发现更底层的操作是通过System.arraycopy这个native方法进行拷贝的。

/**
  @param src     被拷贝的数组
  @param srcPos  从数组那里开始
  @param dest    目标数组
  @param destPos 从目标数组那个索引位置开始拷贝
  @param length  拷贝的长度 
  此方法是没有返回值的，通过 dest 的引用进行传值
 */
public static native void arraycopy
(Object src,int srcPos,Object dest,int destPos,int length);
3.3.4、总结一波
  • 根据扩容的算法，扩容后的大小是原始容量的1.5倍；
  • ArrayList 中的数组容量的最大值是Integer 的最大值(Integer.MAX_VALUE)；
  • 新增过程中，没有对值进行严格校验，所以ArrayList允许null值。
    新增元素操作很简单，elementData [size++] = e，因此非线程安全。

4、删除

4.1、删除元素的方式有很多，不过代码和思路类似，这里选取删除值的方式来分析
// 根据值去删除
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++)
	// 注意这里是根据  equals 来判断值相等的
	if (o.equals(elementData[index])) {
		 fastRemove(index);
		 return true;
	}
  }
	return false;
}
4.2、通过第一步，已经找到了要删除元素的索引，接下来就是根据索引位置来删除元素
private void fastRemove(int index) {
  // 记录数组的结构变化次数
  modCount++;
  // 减 1 的原因，是因为 size 从 1 开始算起，index 从 0开始算起
 // numMoved 用来表示，在删除 index 位置的元素后，需要从 index 后移动多少个元素到前面去
  int numMoved = size - index - 1;
  if (numMoved > 0)
	 // 从 index +1 位置开始被拷贝，拷贝的起始位置是 index
	 System.arraycopy(elementData, index+1, elementData, index, numMoved);
	//给最后一个元素重新赋值为null，然后让GC来对其进行清除
	elementData[--size] = null; 
  }
4.3、总结一波
  • 由于新增元素时允许null值，因此删除的时候也允许删除null值；
  • 在数组中找到目标值的索引位置过程是通过equals来判断的，因此使用非基本类型数组元素的时候需要注意；
  • 当某一个元素被删除后，后面的元素会往前移动，以便于维护数组的结构。

5、迭代器

5.1、由于ArrayList是通过实现java.util.Iterator 类来实现自己的迭代器，因此我们先来了解迭代器的源码
5.1.1、 迭代器的几个主要参数及常用方法

三个重要参数：

// 索引，用来在next里取对应下标的数据
int cursor;       // index of next element to return
// 很巧妙的一个值
// 每次next都会把当前元素的下标赋值给lastRet，如果进行删除操作的话，会用这个值覆盖cursor，使得下一次next依然取这个删除的索引位置上的数据！由于删除元素后，后面的元素会自动前移，那么这个操作就能保证不会漏掉任何一个数据。
int lastRet = -1; // index of last element returned; -1 if no such
// 迭代过程中期望数组修改版本号
int expectedModCount = modCount;

三个基本方法：
hasNext 还有没有值可以迭代
next 如果有值可以迭代，迭代的值是多少
remove 删除当前迭代的值

5.1.2、hashNext源码解析
public boolean hasNext() {
  return cursor != size;//cursor 表示下一个元素的位置，size 表示实际大小，如果两者相等，说明已经没有元素可以迭代了，如果不等，说明还可以迭代
}
5.1.3、next源码解析

迭代器的next和remove是相互联动的，代码层层关联，可谓精妙。通过next方法之后，会把当前遍历的元素的下标索引赋值给lastRet，一方面是可以在remove时删除这个索引的元素，另一方面可以作为已经执行next的证据，通过remove方法内部的的校验。 下面我将逐行去解析，大家多留意lastRet和cursor的变化：

public E next() {
  //迭代过程中，根据modCount 和 expectedModCount是否相等，判断版本号有无被修改，有被修改，抛 ConcurrentModificationException 异常
  checkForComodification();
  //本次迭代过程中，元素的索引位置
  int i = cursor;
  if (i >= size)
    throw new NoSuchElementException();
  Object[] elementData = ArrayList.this.elementData;
  if (i >= elementData.length)
    throw new ConcurrentModificationException();
  // 下一次迭代时，元素的位置
  cursor = i + 1;
  // 返回元素值，并把当前元素的位置赋值为lastRet，这样有两个作用：
  // 1、可以对应删除这个索引位置的元素
  // 2、在迭代器的remove时，可以通过if判断，相当于想要使用迭代器的remove，必须先使用next
  return (E) elementData[lastRet = i];
}
5.1.4、remove源码解析

首先我们要明确一点，就是由于ArrayList每次删除数据后，会把后面的数据前移。而通过上一节next的解析，我们知道了next最终会把当前元素的索引赋值给lastRet。其实remove会根据lastRet删除这个索引的元素，然后后面的数据会前移，所以为了防止下一次next时遍历下一个索引进而漏掉元素，所以在remove后，会把当前索引赋值给cursor，让next继续遍历这个位置的元素。而且为了防止迭代器重复的remove这个索引的元素，因此一会大家可以看到，在remove方法的最后lastRet会被重新赋值1。

public void remove() {
  // 如果没有使用next，此时lastRet是-1，不支持删除数据（由于删除后，这个被删除数据的索引还有从后面移上数据，这样可以防止不小心重复删除某一索引的数据）
  if (lastRet < 0)
    throw new IllegalStateException();
  //迭代过程中，判断版本号有无被修改，有被修改，抛 ConcurrentModificationException 异常
  checkForComodification();

  try {
  	// 调用ArrayList的remove(int index)删除数据
    ArrayList.this.remove(lastRet);
    // 在进行remove之前，已经进行了next，由于此时lastRet就是被删除元素的索引，删除之后，这个索引后面的数据会前移，所以这里把lastRet赋值给cursor，使下一次next继续遍历这个位置的元素，这样就不会漏数据了。
    cursor = lastRet;
    // 继续让lastRet变为-1，这样如果不进行next，就不会进行下一次的remove
    lastRet = -1;
    // 删除元素时 modCount 的值已经发生变化，再此赋值给 expectedModCount，用以在next时通过checkForComodification校验
    expectedModCount = modCount;
  } catch (IndexOutOfBoundsException ex) {
    throw new ConcurrentModificationException();
  }
}
5.1.5、Iterator源码小结一波
  • next方法主要完成两件事，首先检验能不能继续迭代，然后找到并返回迭代的值，并为下一次迭代做准备；
  • lastRet在next场景下表示上一次迭代的元素下标，在remove场景下表示-1，用来防止重复删除元素；
  • 如果删除成功，数组当前的modCount就会发生变化，这里会把expectedModCount重新赋值，下次迭代时两者的值就一致了。

4、线程是否安全

由于ArrayList自身的elementData、size、modCount在进行各种操作时，都没有加锁，并且这些变量都是非volatile类型的，所以如果多个线程对这些变量进行操作时，可能会有值被覆盖的情况。
所以，结合源码我们可以发现当ArrayList作为共享变量时，会有线程安全问题；当ArrayList是方法内的局部变量时，就不存在线程安全问题了。
最开始通过看类注释，我们知道他们推荐我们使用List list = Collections.synchronizedList(new ArrayList(…));来保证线程安全，源码解析如下：

public boolean add(E e) {
    synchronized (mutex) {// synchronized 是一种轻量锁，mutex 表示一个当前 SynchronizedList
        return c.add(e);
    }
}

因此，SynchronizedList 其实是通过在每个方法上面加上锁来实现，虽然实现了线程安全，但是性能大大降低。

5、总结

5.1、ArrayList大小和容量

  • 如果使用无参构造函数创建ArrayList，大小size和初始容量都是0；
  • 如果使用有参构造函数：当指定初始容量，就按照指定的初始容量；如果没有指定初始容量传递值进去，就根据实际size的大小为初始容量；
  • 在无参构造函数初始化的ArrayList进行第一次add操作时，第一次会最少扩容10，如果第一次add进去的数值size大于10，就按照这个size扩容。

5.2、ArrayList扩容总结

当我们使用无参构造函数创建了一个ArrayList时，初始容量为0。当我们add进一个值时，此时的容量为10，size为1。然后接着添加数据时，扩容有两个情况要考虑：

  • 当我们接着add进入10个值时，此时需要扩容，首先根据公式计算1.5倍是15，然后发现15已经可以容纳11个值了，就选择15作为扩容的容量；
  • 当我们接着add进入15个值时，此时需要扩容，首先根据公式计算1.5倍是15，然后发现15无法容纳16个值，就会选择我们期望的容量16作为扩容的容量，这里的判断代码如下：
// newCapacity 本次扩容的大小，minCapacity 我们期望的数组最小大小
// 如果扩容后的值 < 我们的期望值，我们的期望值就等于本次扩容的大小
if (newCapacity - minCapacity < 0)
    newCapacity = minCapacity;

而且需要注意的是，扩容会消耗性能，因为扩容底层使用的是 System.arraycopy 方法，会把原数组的数据全部拷贝到新数组上，所以性能消耗比较严重。

5.3、ArrayList删除总结

5.3.1、为什么普通for循环无法删除干净（漏掉要删除的数据）？

普通for循环调用ArrayList的remove删除数据后，后面的数据会自动向前移。比如一个1，2，3，3，4的ArrayList，我们使用普通for循环，在删除下标为2的元素3后，原本下标为3、4的元素会前移一位，下次循环时我们再遍历下标3时，这时候下标3对应的元素已经是4了，相当于漏掉了一个要删除的元素。

5.3.2、为什么增强for循环删除数据会报错？

因为增强 for 循环过程其实调用的就是迭代器的 next () 方法，当你调用 ArrayList的remove 方法进行删除时，modCount 的值会 +1，而这时候迭代器中的 expectedModCount 的值却没有变，导致在迭代器下次执行 next () 方法时，首先调用checkForComodification()判断时，会由于expectedModCount != modCount 报 ConcurrentModificationException 的错误。

5.3.3、为什么迭代器封装的remove方法可以删干净，且不报错？

这个问题，在网上总结或者回答的是为什么不报错，我没有找到有人解释为什么可以删干净，我们先看为什么不报错：
因为 Iterator.remove 方法在执行的过程中，会把最新的 modCount 赋值给 expectedModCount，这样在下次循环过程中，modCount 和 expectedModCount 两者就会相等，就能通过checkForComodification判断。
那么究竟为什么迭代器封装的remove方法就可以删除干净，不会漏数据呢？
首先，需要肯定的是迭代器封装的remove方法依然是调用的ArrayList的remove(int index)索引删除方法；
下面让我们忽略其它逻辑，把next和remove放在一起从头到remove结束好好看一下：

private class Itr implements Iterator<E> {
    // 索引，用来在next里取对应下标的数据
    int cursor;       // index of next element to return
    // 很巧妙的一个值
    // 每次next都会把当前元素的下标赋值给lastRet，如果进行删除操作的话，会用这个值覆盖cursor，使得下一次next依然取这个删除的索引位置上的数据！由于删除元素后，后面的元素会自动前移，那么这个操作就能保证不会漏掉任何一个数据。
    int lastRet = -1; // index of last element returned; -1 if no such
    // 迭代过程中期望数组修改版本号
    int expectedModCount = modCount;

    public boolean hasNext() {
      return cursor != size;
    }

    public E next() {
      //迭代过程中，根据modCount 和 expectedModCount是否相等，判断版本号有无被修改，有被修改，抛 ConcurrentModificationException 异常
      checkForComodification();
      //本次迭代过程中，元素的索引位置
      int i = cursor;
      if (i >= size)
        throw new NoSuchElementException();
      Object[] elementData = ArrayList.this.elementData;
      if (i >= elementData.length)
        throw new ConcurrentModificationException();
      // 下一次迭代时，元素的位置
      cursor = i + 1;
      // 返回元素值，并把当前元素的位置赋值为lastRet，这样有两个作用：
      // 1、可以对应删除这个索引位置的元素
      // 2、在迭代器的remove时，可以通过if判断，相当于想要使用迭代器的remove，必须先使用next
      return (E) elementData[lastRet = i];
    }

    public void remove() {
      // 如果没有使用next，此时lastRet是-1，不支持删除数据（由于删除后，这个被删除数据的索引还有从后面移上数据，这样可以防止不小心重复删除某一索引的数据）
      if (lastRet < 0)
        throw new IllegalStateException();
      //迭代过程中，判断版本号有无被修改，有被修改，抛 ConcurrentModificationException 异常
      checkForComodification();

      try {
      	// 调用ArrayList的remove(int index)删除数据
        ArrayList.this.remove(lastRet);
        // 在进行remove之前，已经进行了next，由于此时lastRet就是被删除元素的索引，删除之后，这个索引后面的数据会前移，所以这里把lastRet赋值给cursor，使下一次next继续遍历这个位置的元素，这样就不会漏数据了。
        cursor = lastRet;
        // 继续让lastRet变为-1，这样如果不进行next，就不会进行下一次的remove
        lastRet = -1;
        // 删除元素时 modCount 的值已经发生变化，再此赋值给 expectedModCount，用以在next时通过checkForComodification校验
        expectedModCount = modCount;
      } catch (IndexOutOfBoundsException ex) {
        throw new ConcurrentModificationException();
      }
    }

结合前面的解析以及这段完整的代码，相信大家已经知道了为什么同样是remove，而且迭代器的remove只是在原有基础上封装了一次，就能够避免遗漏数据了，这是因为对下标索引进行了巧妙的处理。next和remove在不漏掉数据这方面的大致联动过程如下：

  1. next遍历数组，并把当前元素的索引cursor赋值给lastRet；
  2. 这时候如果执行remove，由于lastRet不再是-1，顺利向下执行，调用ArrayList.this.remove(lastRet)删除当前元素；
  3. 删除之后，用lastRet覆盖cursor，使得下一次遍历，不漏掉元素；
  4. 覆盖之后，重新给lastRet赋值为-1，避免重复删除数据。
Amy.wang96
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ArrayList源码深入解析
OpenSuns的博客
09-20 1499
最近在看《算法与数据结构Java版》这本书，正好看到第三章线性表，就顺便看了一下ArrayList和LinkedList的源码，深入的了解了他们之间的区别和性能方面的优缺点。 概要 ArrayList的实现原理其实就是数组，它是线程不安全的，允许其中元素为null。 它实现了 List&amp;amp;amp;amp;amp;amp;amp;lt;E&amp;amp;amp;amp;amp;amp;amp;gt;, RandomAccess, Cloneable, java.
ArrayList源码深度解析
l1522009509的博客
08-22 132
List接口 **List集合代表一个有序、可重复集合，集合中每个元素都有其对应的顺序索引。**List集合默认按照元素的添加顺序设置元素的索引，可以通过索引（类似数组的下标）来访问指定位置的集合元素。 实现List接口的集合主要有：ArrayList、LinkedList、Vector、Stack。 ...
ArrayList 源码解析
u011035026的博客
11-07 518
自定义循环队列 思考： 在上篇文章中在讨论队列的出队操作时候，其时间复杂度分析为O(n)，这是因为每次出队操作会删除队列的对头，从而导致其数组后续的元素都会往前移动n-1次，那怎么样才能实现队列出队操作的时候其时间复杂度为O(1)呢？ 循环队列定义 队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。 允许插入的一端称为队尾（Tail），允许删除的一端称为队头（Fron...
深入Java集合ArrayList的源码解析
12-21
总的来说，理解ArrayList的源码有助于提升Java编程的深度，对性能优化和异常处理有重要的指导意义。通过分析ArrayList的内部实现，我们可以更好地利用其特性，避免潜在的问题，从而编写出更高效、更健壮的代码。
Java中的ArrayList的底层源码解读、LinkedList、Vector的区别介绍
04-03
内容概要：ArryaList的底层源码分析，时间复杂度的介绍、自动扩容机制的源码分析、add方法、remove方法的底层源码深度解析、modcount的作用、相关数据结构的分析、介绍和比较。 适用人群：JavaSE初学者，对源码感...
Csharp案例开发源码.zip
06-18
《C#案例开发源码深度解析》 C#是一种由微软公司推出的面向对象的编程语言，它是.NET框架的重要组成部分，广泛应用于Windows桌面应用、Web应用、游戏开发、移动应用等多个领域。本篇将深入探讨在C#案例开发中的关键...
jdk源码jdk1.8.0_181
03-06
本文将对这个版本中的关键源码进行深度剖析，旨在帮助开发者理解其内部机制，提升编程技能。 一、核心组件与源码结构 1. **javax**: javax包包含了Java标准扩展，如JDBC（Java Database Connectivity）、JAXP...
ArrayList的源码解析（含详细注释）
SIESTA030的博客
01-24 439
ArrayList的源码自学 1、今日阅读部分 1.1、五个重要参数 DEFAULT_CAPACITY（集合默认容量大小）。 EMPTY_ELEMENTDATA（用于空实例的共享空数组实例）。 DEFAULTCAPACITY_EMPTY_ELEMENTDATA（共享的空数组实例用于默认大小的空实例）。 elementData（arraylist 中存数据的地方）。 size（数据元素个数）。 * Default initial capacity. * 集合的默认容量为10
【JDk源码解析之一】ArrayList源码解析
怪盗基德
04-15 5094
1.ArrayList的继承关系如图所示： 2.宏观上说，ArrayList是基于动态数组实现的，数组具有按索引查找的特性，所以访问很快，适合经常查询的数据。 3.具体源码解析。    为什么说ArrayList是动态数组，这个可以看它的构造函数。如下图所示，有两个构造方法，存放元素的elementData是一个数组，同时被初始化。ArrayList的放的元素就是放      在这个
ArrayList中的put（）方法的实现原理：
最新发布
weixin_53571731的博客
07-13 280
然后判断节点数是否大于8，数组长度是否大于等于64，如果是则执行转为红黑树操作。2、table不为空时，根据要插入的key计算对应的hash值，根据hash值确定再bable中的存储节点位置。如果该节点位置上没有元素，直接插入。如果存在元素，就要比较要插入的key值和节点元素的值是否相同，相同则直接覆盖。1、首先判断table是否为空null或者table长度是否为0，如果是，则调用resize（）方法进行扩容。3、不同，则判断该节点是否为红黑树节点，如果是就执行putTreeVal()方法往树中插入。
ArrayList的实现原理
weixin_43847311的博客
03-25 116
Arraylist内部有着几个变量，object类型的空数组elementdata，一个int类型值为10的default_capacity，然后还有两个空数组分别是empty_elementdata和defaultCapacity_empty_elementdata以及一个记录数组大小的size。 首先从构造方法说起，它有三种构造方法，第一个是默认构造方法，就是直接把defaultCapacity_empty_elementdata这个空数组赋值给elementdata。 第二种是自定义容量的构造方法，你
JAVA入门-集合类
Toolman的博客
03-12 522
在学习集合类之前我们要知道什么是数据结构 数据结构 1.数据结构是计算机存储、组织数据的方式。 2.数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。 3.精心选择的数据结构可以带来更高的运行或者存储效率。 一、线性表 二、哈希表 三、数组 ...
arrayList循环使用add()方法，再put进入map中，发现map中添加了重复值的问题
qq_49721447的博客
03-01 2857
描述：下面的代码，按照逻辑来说，结果应该是： {0=[2],1=[2,3],2=[2,3,4],3=[2,3,4,5],4=[2,3,4,5,6]}。 但其结果实际却是： {0=[2, 3, 4, 5, 6], 1=[2, 3, 4, 5, 6], 2=[2, 3, 4, 5, 6], 3=[2, 3, 4, 5, 6], 4=[2, 3, 4, 5, 6]} Map<Integer,List<Integer>> map = new HashMap<>(); L
ArrayList的具体方法
dsjcn的博客
05-05 439
ArrayList的具体方法 1.add(E e) 方法 package arraylisT; public class shiyuan { }
Java ArrayList工作原理及实现
01-04 371
1. 概述 关于Java集合的小抄中是这样描述的： 以数组实现。节约空间，但数组有容量限制。超出限制时会增加50%容量，用System.arraycopy()复制到新的数组，因此最好能给出数组大小的预估值。默认第一次插入元素时创建大小为10的数组。 按数组下标访问元素—get(i)/set(i,e) 的性能很高，这是数组的基本优势。 直接在数组末尾加入元素—add(e)
常用集合（ArrayList、Hashset、HashMap）的用法（会一直更新）
qq_40262372的博客
11-03 502
ArrayList add 是直接将想要加入的数据加入到list中，加入之前会进行是否扩容检查。get的字面意思是获得。所以是获取想要下标的arraylist数组的值。 Hashmap的底层是由数组+链表结构（链表负责存储数据，实现了内部的Rntry<K,V>接口） put 方法是将键值的旧值被新值覆盖，如果没有出现键值那就直接初始化下一个链表，如果存在的话，覆盖。 get方法，遇到hash值一样返回当前索引的Node,节点不一样那就继续遍历直到相等或为null。 ...
ArrayList深度解析：数据结构与源码剖析
3. ArrayList源码分析 - ArrayList的源码中包含了多种关键操作，如add、remove、get等。其中，add操作涉及到扩容，可能会创建新的数组并复制原有元素；remove操作需要更新索引，确保数组的连续性。 - 在实际使用中...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值