标签：his list nbsp return 线程安全 安全 需要 OLE last
ArrayList：实现RandomAccess 可快速查找元素
初始化：默认初始化大小为10
数据结构：使用数组的线性结构存储数据
是否有序：数组结构有序
扩容方式：当添加元素超过当前容量时，进行扩容 int newCapacity = oldCapacity + (oldCapacity >> 1); 扩大为原来的3/2
线程安全：非线程安全 可以通过 Collections.synchronizedList(a); 方法进行线程安全的操作
优点：数组结构查找很快
缺点：删除和增加（除去在末尾增加）时较慢
在ArrayList中删除某个位置的元素和增加某个位子的元素时执行：
1.检查下标是否越界
2.检查是否需要扩容
3.新建新的数组将原先的数组种元素复制过来
4.执行添加和删除操作
LinkedList：实现了Deque 接口能对元素进行两端的操作
初始化：定义了 第一个Node元素和 最后一个 Node元素
数据结构：双向链表结构
为什么是双向链表结构
private static class Node<E> {
E item;
Node<E> next; //前一个Node节点
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
是否有序：链表结构会有指向前一个元素和后一个元素是有序的
扩容方式：直接增加一个Node节点，将新的Node的向前指针指向最后一个元素
线程安全：非线程安全
优点： 链表结构增加和删除元素时，只需要改变Node中前一个元素和后一个后一个元素的指向
--新增
public boolean add(E e) {
linkLast(e);
return true;
}
void linkLast(E e) {
final Node<E> l = last;
//创建一个向前指针指向当前集合最后一个元素，向后指针为空的Node节点
final Node<E> newNode = new Node<>(l, e, null);
//现在集合中最后一个元素为新的Node
last = newNode;
if (l == null)
first = newNode;
else
//如果当前最后一个节点部位null就将当前最后一个节点的向后指针指向新的Node
l.next = newNode;
size++;
modCount++;
}
--删除
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;
if (prev == null) {
first = next;
} else {
prev.next = next; //将前一个元素指向这个元素的下一个元素
x.prev = null;//将这个元素的向前指针为空
}
if (next == null) {
last = prev;
} else {
next.prev = prev;//将这个元素的下一个元素指向这个元素的前一个元素
x.next = null;//将这个元素的向后指针为空
}
x.item = null;
size--;
modCount++;
return element;
}
缺点：查询较慢
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
//查找元素会将所有元素的一半来循环查找
Node<E> node(int index) {
// assert isElementIndex(index);
if (index < (size >> 1)) {
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
标签：his list nbsp return 线程安全 安全 需要 OLE last
原文地址：https://www.cnblogs.com/sunyangCoder/p/9128783.html
