2021年4月2日更新 使用Android-30 SDK 重新梳理一遍
文章目录
ArrayList这个类用的实在是太频繁了，除基本类型之外应该算是最常用了吧，但是一直用过却一直不曾研究过里面的源码，这是程序员的大忌，用什么就要研究什么，否则只是代码工匠谈不上代码师。
在开始ArrayList学习之前，我一直有个疑问，就是数组可以动态扩容吗？我们知道java声明数组时，必须指明数组的个数或者列举出所有的元素（等于告诉编译器自己长度为多少）
String a[] = new String[]{"1","2","3"};
String b[] = new String[10];
String c[] = new String[];//这一行编译不过去
可是如果我们使用的时候发现数据太多了，数组太小了，需要扩容怎么办呢？
没办法，新建一个数组，将旧的数组数据拷贝到新数组里面
String a[] = new String[]{"1","2","3"};
String b[] = new String[a.length+10];
例子比较简单，这样做尚可但是如果比较复杂的数组怎么处理长度呢？而且即使你处理完了发现数组又小了，该如何是好？继续创建新的数组吗？这样做太麻烦了！
创建一个可改变长度的数组就好了——ArrayList
正因为有了这样的需求，ArrayList横空出世，ArrayList就是可改变长度的数组
Resizable-array implementation of the {@code List} interface.
与此同时，其元素还包括null
Implements all optional list operations, and permits all elements, including {@code null}
Vector线程安全，ArrayList线程不安全，至于为什么不安全可以看这篇博客ArrayList为什么线程不安全 ，本质原因是因为ArrayList的集合是通过数组实现的，但是没有加锁，导致多线程同时操作集合的时候数组会发生越界问题。
(This class is roughly equivalent to {@code Vector}, except that it is unsynchronized.)
其成员变量有下面几个
/**
* Default initial capacity. 默认集合长度为10
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* Shared empty array instance used for empty instances.
* 当你用new ArrayList(0)初始化的时候指定长度为0就会用到这个数组
*/
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.
* 当你使用new ArrayList()生成集合的时候默认使用这个数组，解释具体看后面的代码
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
前面transient 表示是暂时的变量，序列化和反序列化都不会操作这个变量
这个变量什么呢？就是在不断变化的那个数组，就好像我们使用p=head，在不破坏原有指针的情况下，构造了一个局部变量来代替head指针，这个也是如此用于代替上面两个数组
transient Object[] elementData;
集合的长度
需要注意的是size是表示集合的长度，而后续源码中有elementData.length表示的是内部数组的长度，这两个不是一个概念！size是暴露给调用者的，elementData这个数组是底层数组，对于用户是不可知的，他的长度不用和size相同
private int size;
集合最大长度，最大值-8，为啥-8我也不知道？？？？
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
1 初始化ArrayList
List<String> a=new ArrayList<>();
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
DEFAULTCAPACITY_EMPTY_ELEMENTDATA 其实就是一个length =0 的空数组，它的作用只是起到一个过渡作用，但凡需要扩容的话都要重新new 一个数组出来，这个就没用了。
2 add(E e)方法
public boolean add(E e) {
// 这一步很关键牵扯到集合的扩容
ensureCapacityInternal(size + 1);
// 本来size =0 数组无元素，经过上面扩容之后 size = 0但是此时内部的数组已经可以放元素了
// 索引0放了数据之后，此时集合size++ 变成了 size =1
elementData[size++] = e;
return true;
}
// 上面代码 size + 1 = 1 == minCapacity
private void ensureCapacityInternal(int minCapacity) {
// 由于使用无参构造方法，elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
// DEFAULT_CAPACITY = 10 而我们的minCapacity =1 10 >1 所以 minCapacity =10
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// 10 - 0 > 0 要自增
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) {
int oldCapacity = elementData.length; // oldCapacity = 0 minCapacity =10
// >> 是位运算符，可以理解为 >> x 等于这个数除以2的x次方 , 比如 2>>1 = 1 4>>1=2
// newCapacity = oldCapacity + oldCapacity / 2 = 0 + 0 =0
// 所以这里扩容的也不多，只扩容了0.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 0 - 10 < 10 新的容量就是10
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
// 当如果容量太大的话，也不能无限制的扩容，需要使用一个最大值
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 确定好新的容量之后，就要重新拷贝出来一个新的数组了，elementData被重新赋值了，指针指向了新的对象
elementData = Arrays.copyOf(elementData, 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("unchecked")
// 我们的数组内部确实使用的是 Object[] 数组，这里就直接new 了一个新的object 数组
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
//这段代码是集合类类最常见的拷贝数组的方法
// 这句代码的意思是：
// 将original数组从0位置至original.length-1位置，复制到copy数组0位置到Math.min-1位置。
System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
// 这个copy就是现在ArrayList目前最新的数组对象
return copy;
}
3 get(int index)方法
直接从数组中根据索引取数据, 很好理解不再解释了
public E get(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
return (E) elementData[index];
}
4 remove(int index) 和 add(int index,E element)
// 假如目前集合有2个元素 size =2 想删除索引为0（集合中的第一个）的元素 index =0
public E remove(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
modCount++;
// 执行完删除的结果就是返回被删除的元素
E oldValue = (E) elementData[index];
// 要移动的索引 numMoved = 2 - 0 -1 = 1 > 0
int numMoved = size - index - 1;
if (numMoved > 0)
// 之前elementData 数组是 x1 x2
// 现在elementData 数组是 x2 null
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
// 因为让整个数组前移了一位，所以 size = 2 变成 size =1了
// 所以elementData数组只剩下 x2 了
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
// 假如目前集合有2个元素{x1 x2} size =2 想要在index = 0插入一个x0元素
public void add(int index, E element) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
//这个之前介绍了，就是扩容 此时数组已经扩容了
ensureCapacityInternal(size + 1); // Increments modCount!!
// 之前的数组 x1 x2
// 新的数组 null x1 x2
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
// 新的数组 null x1 x2 => x0 x1 x2
elementData[index] = element;
// 集合长度增加1
size++;
}
5 remove(Object o)
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进行比较的 如果有特殊的去重需求需要重写这个equals方法
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
private void fastRemove(int index) {
modCount++;
int numMoved = size - index - 1;
if (numMoved > 0)
// 这个和remove(int index) 逻辑很像，就是把该索引之后的数据提前到此位置
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // clear to let GC do its work
}
6 clear()方法
public void clear() {
modCount++;
// clear to let GC do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
数组还在，只是里面每个数据变成空了而已，但是size已经被赋值成了0，也就是说对于外部来说这个集合为空但是实际上里面还是有数组的。
7 addAll()方法
public boolean addAll(Collection<? extends E> c) {
// 源码没有判空所以很容易因为我们addAll一个空集合导致空指针异常
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}
如有不足之处，欢迎批评指正~ 一起学习~
252
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
