LinkedList
节点数据结构
/**
* 泛型结构
* @param <E> node
*/
private static class Node<E> {
E item;
// 双向链表，向前和向后
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
add
结论：新节点是插入到原来index的前面，原来index以及以后的节点，整体后移一位
/**
* Returns the (non-null) Node at the specified element index.
* 这里索引用了二分的思想，但是不是二分的算法
* 首先区分index是否小于一般，如果是，那么从前往后找
* 如果大于一般，那么从后往前找
*/
Node<E> node(int index) {
// assert isElementIndex(index);
if (index < (size >> 1)) {
// 从first往后
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
// 从last往前
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
/**
* Inserts element e before non-null Node succ.
*/
void linkBefore(E e, Node<E> succ) {
// assert succ != null;
final Node<E> pred = succ.prev;
final Node<E> newNode = new Node<>(pred, e, succ);
// 断开原来的前置连接线，并修改为新的
succ.prev = newNode;
if (pred == null) {
first = newNode;
} else {
// 断开原来的后置，并更新
pred.next = newNode;
}
size++;
modCount++;
}
reomove，removeFirst，remove（index）
remove默认移除首节点，于removefirst作用相同
/**
* Unlinks non-null first node f.
*/
private E unlinkFirst(Node<E> f) {
// assert f == first && f != null;
final E element = f.item;
final Node<E> next = f.next;
f.item = null;
f.next = null; // help GC
first = next;
if (next == null)
last = null;
else {
// 更新完first之后，这里只需要把next.prev对象设置为null即可
next.prev = null;
}
size--;
modCount++;
return element;
}
/**
* Unlinks non-null node x.
*/
E unlink(Node<E> x) {
// assert x != null;
final E element = x.item;
final Node<E> next = x.next;
final Node<E> prev = x.prev;
// 前置节点为空，那么直接把first移动到next
if (prev == null) {
first = next;
} else {
// 把前面节点的后置设置为下一个，跳过当前节点
prev.next = next;
x.prev = null;
}
// 如果next本来是空的，那么把last指针前移
if (next == null) {
last = prev;
} else {
// 不为空，那么把后面节点的前置指针跳过当前，设置前面一个节点
next.prev = prev;
x.next = null;
}
x.item = null;
size--;
modCount++;
return element;
}
remove（index）和 remove(Object)类似
但是remove(object)的意思是判断空和非空，因为空的无法进行equals比较,循环查找
另外remove(index)也是先根据node方法定位关联节点
get，indexof查找
get方法也是用node(index)定位，indexof方法：判断空和非空，因为空的无法进行equals比较，循环查找
参考
https://pdai.tech/md/java/collection/java-collection-LinkedList.html#queue-方法
Stack
栈的实现主要依赖的是vector
这里主要是push和pop操作
扩容参考arraylist
push就是类似add，但是这里的操作都加了synchronized关键字，所以stack是线程安全的
CopyOnWriteArrayList
add操作
public boolean add(E e) {
// 加锁
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
// 先直接复制一个新的数组出来,并且直接把长度+1
Object[] newElements = Arrays.copyOf(elements, len + 1);
// 然后设置最后一个位置的节点
newElements[len] = e;
setArray(newElements);
return true;
} finally {
lock.unlock();
}
}
扩容
这个结构的扩容方式很简单暴力
直接复制出来一份满足要求大小的数组
newElements = Arrays.copyOf(elements, len + 1);
get
没有加锁
private E get(Object[] a, int index) {
return (E) a[index];
}
总结：
数据一致性问题：CopyOnWrite容器只能保证数据的最终一致性，不能保证数据的实时一致性。
这句话的意思是在循环操作的过程中，这个get结果是不可知的，只能保证在set的时候没问题，然后所有数据add完毕之后的结果符合预期
内存占用问题：因为CopyOnWrite的写时复制机制，所以在进行写操作的时候，内存里会同时驻扎两个对象的内存，旧的对象和新写入的对象（注意:在复制的时候只是复制容器里的引用，只是在写的时候会创建新对象添加到新容器里，而旧容器的对象还在使用，所以有两份对象内存）