【Java】ArrayList实现原理浅析，Java框架体系架构的知识

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

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

2.1.2 指定数组容量大小参数的构造函数

指定容量>0，直接new一个指定大小的对象数组； =0，指定一个空对象数组 <0，抛异常

private static final Object[] EMPTY_ELEMENTDATA = {};

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);
}
}

2.1.3 集合参数的构造函数

a.将集合转化成数组 b.判断数组的长度，length!=0；true，判断数组类型是否为Object类型数组？->否，拷贝elementData的数据，拷贝为Object数组，赋值给elementData false:设置elementData为空对象数组

private static final Object[] EMPTY_ELEMENTDATA = {};
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}

2.1.4 什么是数组的深拷贝和浅拷贝？

深拷贝：不单单是引用拷贝，还开辟一块新的内存空间

浅拷贝： 引用拷贝

Q：这里的Arrays.copyOf深拷贝还是浅拷贝？ A：浅拷贝，只复制了对象的引用，即内存地址，并没有为每个元素新创建对象。 原因就不过多解释了，具体去查看这篇博客吧。blog.csdn.net/abysscarry/…

2.2.扩容机制发生的时间

add()的时候调用

1.add(E e) ；添加具体某个元素 代码操作释义：检测是否需要扩容操作；将集合中实际元素个数+1；

public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}

2.add(int index, E element) ；根据下标去添加某个元素

public void add(int index, E element) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

ensureCapacityInternal(size + 1); // Increments modCount!!
//原数组；源数组要复制的起始位置；目标数组；目标数组复制的起始位置；要copy的数组的长度
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}

这里的System.arraycopy()是深拷贝还是浅拷贝？

答：只有数组为一维数组，并且元素为基本类型或String类型时，才是深复制，其它都属于浅复制； System.arraycopy()常用作数组的扩容，如ArrayList底层数组的扩容

2.3插入数据时，ArrayList和LinkedList的区别

2.3.1 ArrayList如何插入数据？

曾几何时，你麻木的记住，ArrayList.add（index，e）效率<LinkedList的add，时至今日，打工人顿悟了。来，让我们一层一层的剥开他的衣服…呸，代码！ System.arraycopy(elementData, index, elementData, index + 1,size - index);你看看这句代码都干了些什么事儿。

为了在指定的下标插入一个数据，我们要把目标index的位置到size-index的数据全都进行复制，紧紧是为了给某个add的数据让位。

倘若数组长度是100，然后add(0,element)，也就意味，为了给他让位，我们需要拷贝移动1-99的数据位置。

2.3.2 LinkedList是如何插入数据？

public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}

void linkBefore(E e, Node succ) {
// assert succ != null;
final Node pred = succ.prev;
final Node newNode = new Node<>(pred, e, succ);
succ.prev = newNode;
if (pred == null)
first = newNode;
else
pred.next = newNode;
size++;
modCount++;
}

分析：linkBefore（element，node（index）），传入的参数是：1.目标元素；2.目标元素的当前节点对象。

LinkedList插入数据过程：

1. 获取当前的目标节点的pre=pred；
2. new一个新的结节点newNode，3个参数代表着:a.当前操作节点的pre=pred；b.元素e=e；c.下一个节点next=succ；
3. 把new的新节点，设置给当前操作节点的pre。（将操作节点的pre设置为新插入的元素节点）
4. 判断当前插入的元素位置是否为LinkedList的头节点；若不是的话，则将当前操作元素节点的next指为new的要插入进来的那个节点。（将操作节点的next指向新插入的元素的节点）

在某个位置插入某个元素的大概流程如图所示： 也就是说，我们通过LinkedList向某个位置插入一个数据，我们只需要改变两个数据节点的pre和next指向就完成了。

ArrayList和LinkedList的插入效率比较

ArrayList的add是尾部：效率ArrayList>LinkedList； ArrayList的add是头部：效率ArrayList<LinkedList

原因：ArrayList的内存空间连续，且不需要复制数组。LinkedList需要创建一个新的节点，前后引用进行重新排列。

我不知道你们有没有恍然大悟，但是我恍然大悟了。

接下来就是揭开扩容的真面目了，扩容和构造器有什么关系？

2.4 触发扩容以及扩容大小

上面说扩容机制是在add(e)时触发的，来看看add(e)的源码：

add(E e)

public boolean add(E e) {

《一线大厂Java面试题解析+后端开发学习笔记+最新架构讲解视频+实战项目源码讲义》

【docs.qq.com/doc/DSmxTbFJ1cmN1R2dB】 完整内容开源分享

ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}

ensureCapacityInternal(int minCapacity) :确保插入元素容器最小的值； minCapacity：当前数组的长度+1

构造函数为空参数构造函数，则给minCapacity设置默认的值为minCapacity=DEFAULT_CAPACITY=10； 若不为空参数构造函数，则minCapacity=数组已存在数据size+1

private static final int DEFAULT_CAPACITY = 10;
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}

ensureExplicitCapacity(int minCapacity) :判断是否需要扩容 elementData.length是现有数据的长度。

private void ensureExplicitCapacity(int minCapacity) {
modCount++;

// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}

grow(int minCapacity) :实现扩容

1. 获取旧容量
2. 现将原元素数组的长度增大1.5倍，随后和newCapacity比较。
3. 新容量小于参数指定容量，修改新容量：newCapacity（新增容量）<minnewCapacity：newCapacity=minCapacity
4. 新容量大于最大容量：newCapacity>minnewCapacity：newCapacity:将就数组拷贝到扩容后的新数组中。

private void grow(int minCapacity) {
int oldCapacity = elementData.length; //旧容量
int newCapacity = oldCapacity + (oldCapacity >> 1); //新容量为旧容量的1.5倍
if (newCapacity - minCapacity < 0) //新容量小于参数指定容量，修改新容量
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0) //新容量大于最大容量
newCapacity = hugeCapacity(minCapacity); //指定新容量
//拷贝扩容
elementData = Arrays.copyOf(elementData, newCapacity);
}

第一次调用添加元素的add和addAll，size=0，则minCapacity=1 如果ArrayList给了特定的初始值，则需要根据数组实际长度和数组容量差来判断是否调用扩容；如果没有指定初始容量，第一次调用add则一定需要调用grow()

三.ArrayList的线程安全性

在多线程下，ArrayList不能保证原子性(即同一时刻只能有一个线程来对它进行操作)。

举个栗子：线程A对ArrayList进行++处理，期待100；线程B对ArrayList进行–处理，期待98。多线程进行时，可能本应该为100，因为又有–操作，可能++后，结果仍然为99.

多线程环境下，ArrayList线程是不安全的。

保证线程安全性的方法：

1.使用synchronized关键字；

在多线程下，ArrayList不能保证原子性(即同一时刻只能有一个线程来对它进行操作)。

举个栗子：线程A对ArrayList进行++处理，期待100；线程B对ArrayList进行–处理，期待98。多线程进行时，可能本应该为100，因为又有–操作，可能++后，结果仍然为99.

多线程环境下，ArrayList线程是不安全的。

保证线程安全性的方法：

1.使用synchronized关键字；