0、transient
- 被它修饰的元素不会被序列化
使用另外的序列化方式,节省了空间(ArrayList的容量>=实际元素数量,如果直接序列化ArrayList的elementData[]元素数组,会把不含元素的空间也序列化,造成空间的浪费) - 这是一个用于存储ArrayList元素的缓冲数组,ArrayList的容量是数组的长度。
任意一个空的,使用无参构造方法创建出来的ArrayList,第一次添加元素的时候,都要被扩充到默认初始化容量。

- 序列化
把ArraList实例以流的形式保存
/**
* Save the state of the <tt>ArrayList</tt> instance to a stream (that
* is, serialize it).
*
* @serialData The length of the array backing the <tt>ArrayList</tt>
* instance is emitted (int), followed by all of its elements
* (each an <tt>Object</tt>) in the proper order.
*/
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
// Write out element count, and any hidden stuff
// 写出元素计数和其他隐式的属性,序列化期间被修改就会抛出异常
int expectedModCount = modCount;
s.defaultWriteObject();
// Write out size as capacity for behavioural compatibility with clone()
// 将实际元素个数,作为用于克隆的可信的容量
s.writeInt(size);
// Write out all elements in the proper order.
// 依次写入元素
for (int i=0; i<size; i++) {
s.writeObject(elementData[i]);
}
// 多线程修改数据,抛出异常
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
- 反序列化
从流里读出数据,重组ArrayList
/**
* Reconstitute the <tt>ArrayList</tt> instance from a stream (that is,
* deserialize it).
*/
// 从流里读
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// 数组置空
elementData = EMPTY_ELEMENTDATA;
// Read in size, and any hidden stuff
// 读入元素个数和其他隐藏属性
s.defaultReadObject();
// Read in capacity
// 读入容量 ignore 说明这一步没啥用
s.readInt(); // ignored
// 就像克隆一样,给数组分配空间,依据实际元素值而不是容量大小
if (size > 0) {
// be like clone(), allocate array based upon size not capacity
// 计算容量
int capacity = calculateCapacity(elementData, size);
SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, capacity);
//判断扩容
ensureCapacityInternal(size);
// 读取元素
Object[] a = elementData;
// Read in all elements in the proper order.
for (int i=0; i<size; i++) {
a[i] = s.readObject();
}
}
}
1、 变量含义
- int DEFAULT_CAPACITY 默认初始化容量 10
- Object[] EMPTY_ELEMENTDATA 空数组
构造方法带初始容量,但是初始容量为0

构造方法带集合参数,但是集合为空

- Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA 空数组
只用于无参构造

- Object[] elementData 真正存储元素的位置
(无参,创建的是空数组;有参,但是容量为0,创建的也是空数组,两个空数组只是变量名字不同,用于区分不同的构造情况,然后在第一次新增元素的时候采用不同的扩容方式)
ArrayList arrayList = new ArrayList();对于这个 size是0,第一次add的时候,才变为10
/**
* The array buffer into which the elements of the ArrayList are stored.
* The capacity of the ArrayList is the length of this array buffer. Any
* empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
* will be expanded to DEFAULT_CAPACITY when the first element is added.
*/
transient Object[] elementData;
- int size 当前list内 含有的元素个数,注意和 容器容量区分开
private static final int DEFAULT_CAPACITY = 10;
/**
* Shared empty array instance used for empty instances.
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
* Shared empty array instance used for default sized empty instances. We
* distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
* first element is added.
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
2、在末尾新增元素以及扩容
先确保容量够用,再赋元素
/**
* Appends the specified element to the end of this list.
*/
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
- 先计算需要的最小容量 (也就是添加成功之后,实际元素个数)
传入参数 minCapacity = size+1
返回值 = 无参且第一次新增?max(minCapacity,default_Capicaty):minCapacity
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
- modCount++(多线程操作,抛出异常),并判断 所需容量和数组实际长度的关系,来决定是否扩容
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
- 数组空间不够 ——> 扩容
newCapacity = oldCapacity+oldCapacity/2, 也就是1.5倍,然后进行边界判断:如果新容量还是不够用,直接使用minCapacity;如果新容量超过max_size,使用最大容量- 然后用新容量 拷贝数组(副本),然后赋给elementData
/**
* Increases the capacity to ensure that it can hold at least the
* number of elements specified by the minimum capacity argument.
*
* @param minCapacity the desired minimum capacity
*/
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
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);
}
3、在指定位置添加/删除元素
数组的两种复制方式 Arrays/System
- Arrays.copyOfRange(源数组,起点,终点后一个位置)


Arrays.copyof (源数组,复制长度) 基于System.arraycopy()
新建了一个数组副本,最后返回副本


复制长度超过源数组,默认值来凑(int --0 String–null)

- System.arraycopy(源数组,源数组起始位置,目标数组,目标数组起始位置,复制长度)
目标数组必须已经存在–可以是自己 原地修改


正文
- 先判断要添加元素的位置 是不是合规

- 再判断是否需要扩容
- 然后进行数组复制
public void add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1); // Increments modCount!!
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
- 删除也差不多 走流程 然后原地复制 最后返回被删除的元素(如果是boolean,删除成功返回true,失败返回false)

4、其他方法
- get 直接调用数组获取元素的方法 O(1)


- toArray 返回的是副本

- 清空 遍历 赋予null O(n)

- indexOf 遍历,比值 O(n)


1978

被折叠的 条评论
为什么被折叠?



