ArrayList的源码分析
为此要通过源码了解以下特点:1.用动态数组实现 2.线程不安全 3.查找快,增删慢
首先是三个构造方法:
public ArrayList(int initialCapacity) {
//如果大于0 就直接初始一个该长度的数组对象 并赋值回去
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
//等于0 的话就空数组对象empty_elementdata 复制 private static final Object[] EMPTY_ELEMENTDATA = {};
this.elementData = EMPTY_ELEMENTDATA;
} else {
//否则就抛出异常
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
和
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
public ArrayList(Collection<? extends E> c) {
//先把c集合转换为数组
Object[] a = c.toArray();
//在判断数组是不是等于0
if ((size = a.length) != 0) {
//如果类型应用 就直接赋值
if (c.getClass() == ArrayList.class) {
elementData = a;
} else {
//不然就进行数组的拷贝
elementData = Arrays.copyOf(a, size, Object[].class);
}
} else {
//如果等于0 就引用一个空数组
// replace with empty array.
elementData = EMPTY_ELEMENTDATA;
}
}
然后是ArrayList 新增对象
这里要注意的是 jdk12 的add方法进行了修改!!!
public boolean add(E e) {
//直接记录ArrayList的变化次数
modCount++;
//调用私有的add方法
add(e, elementData, size);
return true;
}
私有的方法
private void add(E e, Object[] elementData, int s) {
//r如果长度够的话 就进行扩容
if (s == elementData.length)
elementData = grow();
//没有满的话 就直接赋值 再把size增加
elementData[s] = e;
size = s + 1;
}
关于grow 这里有个知识点
将oldCapacity 右移一位,其效果相当于oldCapacity
/2,//我们知道位运算的速度远远快于整除运算,整句运算式的结果就是将新容量更新为旧容量的1.5倍
private Object[] grow(int minCapacity) {
int oldCapacity = elementData.length;
if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
//这里就设置了新的Capacity是原来的1.5倍
int newCapacity = ArraysSupport.newLength(oldCapacity,
minCapacity - oldCapacity, /* minimum growth */
oldCapacity >> 1 /* preferred growth */);
return elementData = Arrays.copyOf(elementData, newCapacity);
} else {
return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
}
}
双参数的add
//双参数的
public void add(int index, E element) {
//先检查add位置是否合理
rangeCheckForAdd(index);
//ArrayList 增加次数加一
modCount++;
final int s;
Object[] elementData;
//size等于缓冲区的长度 直接扩容
if ((s = size) == (elementData = this.elementData).length)
elementData = grow();
//调用系统的数组copy方法,比如123456 index=3 执行一下就是 1234456 再把对应换成element 也就是系统的增大方式吧
System.arraycopy(elementData, index,
elementData, index + 1,
s - index);
elementData[index] = element;
size = s + 1;
}
再是ArrayList的移除元素
public E remove(int index) {
//先判断有没有越位
Objects.checkIndex(index, size);
final Object[] es = elementData;
//这个备注就是 如果前面没有出错的话 就将原本要删除的值 赋予oldValue 作为返回值
@SuppressWarnings("unchecked") E oldValue = (E) es[index];
//再调用 快速删除的方法来进行删除
fastRemove(es, index);
return oldValue;
}
fastRemove
private void fastRemove(Object[] es, int i) {
modCount++;
final int newSize;
//因为值删除一个数 所以newSize作为删除完了之后的大小 是需要判断并且大于i的,不然会报出异常
if ((newSize = size - 1) > i)
//这里就是调用了 系统的复制方法 假设就是从es[i+1] 这个地方开始拷贝 覆盖掉es[i]这个位置 从后往前开始拷贝的
//假设 是123456 i等于2 就会执行变成 124566
System.arraycopy(es, i + 1, es, i, newSize - i);
//并且将最后一位设置为null
es[size = newSize] = null;
}
从这里可以发现一个细节:
在元素移除的时候,并没有缩小数组的长度(size 不是数组的length ,只是一个长度的标识) ,而仅仅是将后面的数组向前排列,然后将最后一个数组设置为Null
还有一种重载的remove方法:
public boolean remove(Object o) {
final Object[] es = elementData;
final int size = this.size;
int i = 0;
found: {
//如果元素等于null 就找到数组中为Null 的值 进行删除
if (o == null) {
for (; i < size; i++)
if (es[i] == null)
break found;
} else {
//如果不为null 就equals到对应的值 然后还是用fastRemove 进行删除
for (; i < size; i++)
if (o.equals(es[i]))
break found;
}
return false;
}
fastRemove(es, i);
return true;
}
从这里也可以发现一个细节: 只要发现当前元素等于目标元素的话 就立刻停止删除,删除之后也并不会继续遍历完,所以每次都只会删除一个元素, 就像
123null4null5 调用方法之后 就变成 1234null5
而且这里把null 和不是null分开写
主要是因为,后面要调用0.equals() 方法进行判断 如果是null的话 就会出现空指针异常了。
然后是LinkList
对于这个来说,重点就是双向链表的实现,支持null和重复值。好像和ArrayList一样,没有强调是不是重复的值,并且由于链表的存在,不需要扩容。
关于构造函数
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
public boolean addAll(int index, Collection<? extends E> c) {
//检查是否有序
checkPositionIndex(index);
Object[] a = c.toArray();
int numNew = a.length;
if (numNew == 0)
return false;
//初始化 一个是尾部 一个是头部
LinkedList.Node<E> pred, succ;
if (index == size) {
//如果需要插入的就是在尾部的话 就把尾部设置为null,头部设置为最后一个位置
succ = null;
pred = last;
} else {
//不然的话 就是在中间插入尾部指向对应要插入的位置 头部就指向尾部的前面一个
succ = node(index);
pred = succ.prev;
}
for (Object o : a) {
@SuppressWarnings("unchecked") E e = (E) o;
//先构造一个新的结点
LinkedList.Node<E> newNode = new LinkedList.Node<>(pred, e, null);
//如果前置结点是null的话 说明没有前置结点 就可以理解为在链表的头部插入那就需要设置新的结点为前置结点
if (pred == null)
first = newNode;
else
//不然的话 就把新的结点插入到前置结点的后一个
pred.next = newNode;
pred = newNode;
}
if (succ == null) {
//如果后置节点是null 的话 也就是说明是从尾部插入的 那就将原本的前置结点设置为原来链表的最后一个节点
last = pred;
} else {
//不然的话 就通过另一个方法插入
pred.next = succ;
succ.prev = pred;
}
size += numNew;
modCount++;
return true;
}
然后是add方法:
public boolean add(E e) {
linkLast(e);
return true;
}
再看一下 LinkLast
void linkLast(E e) {
final LinkedList.Node<E> l = last;
final LinkedList.Node<E> newNode = new LinkedList.Node<>(l, e, null);
last = newNode;
//这个的意思 应该算是默认从尾部插入
// 如果这个尾部的结点是null 也就是空的话, 也就是last是空
if (l == null)
//那就说明链表是空的 将新的结点设置为null即可
first = newNode;
else
//不然的话 就把新的结点插入到最后一个位置当中
l.next = newNode;
size++;
modCount++;
}
所以是默认会把元素添加到尾部的
然后是把元素添加到指定位置
public void add(int index, E element) {
//先检查有没有越界
checkPositionIndex(index);
//如果刚好在尾部的话 就直接按照原来的 从尾部插入
if (index == size)
linkLast(element);
else
//不然就是调用这个方法 进行正常的插入
linkBefore(element, node(index));
}
LinkBefore方法
void linkBefore(E e, LinkedList.Node<E> succ) {
// assert succ != null;
//前提是当前结点不为空
final LinkedList.Node<E> pred = succ.prev;
//初始化一个新结点 前驱是pred 后继是succ
final LinkedList.Node<E> newNode = new LinkedList.Node<>(pred, e, succ);
//然后把succ的前驱指向新结点
succ.prev = newNode;
//如果前驱是空的话 说明当前元素是第一个元素 或者当前链表为空
if (pred == null)
first = newNode;
else
//否则 pred的后继就变成了 之前succ的前驱
pred.next = newNode;
//新增了一个 就需要操作数和大小都加一
size++;
modCount++;
}
大概的思路就是:
1.创建新的结点 并指明新结点的前驱和后继
2.将succ的前驱引用指向新结点
3.如果succ的前驱不为空的话 就把succ的前驱(之前的前驱)的后继指向新结点
然后是LinkList的移除方法
public boolean remove(Object o) {
//如果要删除的就是null的话(这里有个前提就是 linkedlist就是可以存在null的)
if (o == null) {
//然后从第一个开始遍历
for (LinkedList.Node<E> x = first; x != null; x = x.next) {
if (x.item == null) {
//unlink就是直接删去的意思吧
unlink(x);
return true;
}
}
} else {
//不然的话 就一个个遍历 这边把两个都分开也是因为 下面是需要equals 直接用null会报错
for (LinkedList.Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}
还有按索引的
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
所有就需要再看一下 unlink
E unlink(LinkedList.Node<E> x) {
// assert x != null;
//先进行初始化
final E element = x.item;
final LinkedList.Node<E> next = x.next;
final LinkedList.Node<E> prev = x.prev;
//如果前是null的话 有可能就是头 表示x是第一个元素 直接让first 指向x的后继 相当于就是删掉了
if (prev == null) {
first = next;
} else {
//也就是不是在第一个的话 前驱指向x的后继 再让x 的前驱直接断了
prev.next = next;
x.prev = null;
}
//上面是双向链表的前驱部分
//再判断后继 如果是null 的话 就说明就是最后一个
if (next == null) {
//直接把last指向后继
last = prev;
} else {
//不然的话 就进行 后继的删除 后继的前驱等于原来的前驱 后继直接指向null
next.prev = prev;
x.next = null;
}
x.item = null;
size--;
modCount++;
return element;
}
这些就都是 关于数据结构中链表的增加和删除的知识
参考了这个:
https://blog.csdn.net/laobanhuanghe/article/details/106162498