ArrayList:
介绍:
ArrayList底层维护了一个Object类型的数据elementData,可以添加null元素,并且数据可重复,线程不安全。它会随着容器中的元素不断增加,当快溢出时就会自动扩容。
成员变量:
//序列化ID
private static final long serialVersionUID = 8683452581122892189L;
//进行扩容操作后的最小容量
private static final int DEFAULT_CAPACITY = 10;
//如果外部为集合设置的初始化大小为 0，则将 elementData 指向此空数组
private static final Object[] EMPTY_ELEMENTDATA = {};
//如果在初始化集合时使用的是无参构造函数，则将 elementData 指向此空数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//用来存放元素的数组
transient Object[] elementData;
//集合大小
private int size;
//ArrayList 的快照版本号
protected transient int modCount = 0;
构造函数:
- 如果已经知道目标数据量大小的话，在初始化 ArrayList 的时候我们可以直接传入最终的容量值，这样效率会更高一些。因为如果 initialCapacity 过大，则会造成内存浪费；如果 initialCapacity 过小，可能会导致后续需要多次扩容，每次扩容都需要复制原有数据到新数组，这会降低运行效率
- 如果我们使用的是无参构造函数或者是指定的 initialCapacity 为 0，此时也只会将 elementData 指向空数组，并不会新建一个数组变量
//指定集合的初始容量，以此来进行数组的初始化操作
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
}
}
//外部没有指定初始容量，暂且使用空数组
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//传入一份初始数据来进行初始化
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
this.elementData = EMPTY_ELEMENTDATA;
}
}
获取元素:
在获取指定索引处的元素时，ArrayList 都是直接通过坐标值来获取元素，无需从头遍历，所以说 ArrayList 遍历和随机访问的效率较高
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
}
public E get(int index) {
//判断取值范围是否合法
rangeCheck(index);
return elementData(index);
}
添加元素:
- ArrayList 添加元素的操作就不是那么理想了。如果是直接向集合尾端添加数据，那么直接定位到该位置进行赋值即可；如果是向集合的中间位置 index 插入数据，则需要将数组中索引 index 后的所有数据向后推移一位，然后将数据插入到空出的位置上。此外，在插入数据前 elementData 可能已经空间不足了，那么还需要先进行扩容操作。扩容操作会创建一个新的符合大小的数组，并将原数组中的数据迁移到新数组中，然后让 elementData 指向新数组
- 由此可以看出来，向集合添加数据和进行扩容都可能会导致数组元素大量移动，所以说 ArrayList 存入数据的效率并不高
public boolean add(E e) {
//在需要的时候进行扩容
ensureCapacityInternal(size + 1);
elementData[size++] = e;
return true;
}
public void add(int index, E element) {
rangeCheckForAdd(index);
//在需要的时候进行扩容
ensureCapacityInternal(size + 1);
//将索引 index 后的所有数值向后推移一位
System.arraycopy(elementData, index, elementData, index + 1,size - index);
elementData[index] = element;
size++;
}
移除元素:
因为数组是一种内存地址连续的数据结构，所以移除某个元素同样可能导致大量元素移动
//移除指定索引处的元素值，并返回该值
public E remove(int index) {
rangeCheck(index);
modCount++;
//待移除的元素值
E oldValue = elementData(index);
//因为要移除元素导致需要移动的元素数量
int numMoved = size - index - 1;
//因为要移除的元素可能刚好是数组最后一位，所以 numMoved 可能为 0
//所以只在 numMoved > 0 的时候才需要对数组的元素值进行移动
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index, numMoved);
//不管数组是否需要对元素值进行移动，数组的最后一位都是无效数据了
//此处将之置为 null 以帮助GC回收
elementData[--size] = null;
return oldValue;
}
//移除集合中包含的第一位元素值为 o 的对象
//如果包含该对象，则返回 true ，否则返回 false
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++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
扩容操作:
- 当创建ArrayList对象时,如果使用的是无参构造器,则初始化elementData容量为0,第一次添加,则扩容elementData为10,如果需要再次扩容,则扩容elementData为1.5倍
- 如果使用的是指定大小的构建器,则初始化elementData容量为指定大小,如果需要扩容,则直接扩容elementData为1.5倍
- 完成扩容操作的是 grow(int minCapacity) 方法。在扩容前,会先判断如果将容量提升到当前的1.5倍是否能达到minCapacity的要求,如果符合要求则直接将容量扩充到当前的1.5倍,否则就扩充到minCapacity,但最终容量不能大于Integer.MAX_VALUE。构建出一个新的符合大小的数组后,就将原数组中的元素复制到新数组中,至此就完成了扩容
ArrayList<Integer> list = new ArrayList<>();
for (int i = 1; i < 10; i++) {
list.add(i);
}
public boolean add(E e) {
ensureCapacityInternal(size + 1); //先确定是否要进行扩容
elementData[size++] = e; //赋值
return true;
}
//确定是否要进行扩容
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
//计算容量
private static int calculateCapacity(Object[] elementData, int minCapacity) {
//只有当第一次添加数据时,if才会执行,返回10
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
//是否要扩容
private void ensureExplicitCapacity(int minCapacity) {
modCount++;//记录当前集合被需改的次数,防止多个线程同时修改它,如果多个线程同时修改它,会抛异常
//如果需要的最小容量 减去 数组当前容量 大于0 说明 需要扩容
//例如第一次添加 mincapacity为1 1-0 那么 1>0 就需要扩容操作
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
//minCapacity:需要的最小容量
private void grow(int minCapacity) {
//将当前数组长度赋值给 oldCapacity
int oldCapacity = elementData.length;
//原数组大小+原数组大小除以2 扩容1.5倍
//但是第一次添加时,oldCapacity=0
int newCapacity = oldCapacity + (oldCapacity >> 1);
//如果新的容量比需要的最小容量还小,直接使用minCapacity
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//新的容量比最大值还大
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
//将数组扩容
elementData = Arrays.copyOf(elementData, newCapacity);
}
修改元素:
//将索引 index 出的元素值置为 element，并返回原始数值
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
LinkedList:
介绍:
LinkedList 同时实现了 List 接口和 Deque 接口，所以既可以将 LinkedList 当做一个有序容器，也可以将之看作一个队列（Queue），同时又可以看作一个栈（Stack）。虽然 LinkedList 和 ArrayList 一样都实现了 List 接口，但其底层是通过双向链表来实现的，所以插入和删除元素的效率都要比 ArrayList 高，但也因此随机访问的效率要比 ArrayList 低
ArrayList是数组实现的，LinkedList是双向链表实现的,LinkedList的节点存储了两个引用,一个指向前一个节点,一个指向后一个节点。
LinkedList不需要去请求一片连续的内存空间来存储数据,而是在每次有新元素需要添加时再来动态请求内存空间。
1.类声明
从 LinkedList 实现的几个接口可以看出来，LinkedList 是支持快速访问，可克隆，可序列化的，而且可以将之看成一个支持有序访问的队列或者栈
public class LinkedList<E> extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
LinkedList 内部通过双向链表的数据结构来实现的，每个链表结点除了存储本结点的数据元素外，还有两个指针分别用于指向其上下两个相邻结点，这个结点就是 LinkedList 中的静态类 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;
}
}
2.成员变量
//双向链表包含的结点总数，即数据总量
transient int size = 0;
//双向链表的头结点
transient Node<E> first;
//双向链表的尾结点
transient Node<E> last;
//序列化ID
private static final long serialVersionUID = 876323262645176354L;
3.构造函数
LinkedList 不需要去请求一片连续的内存空间来存储数据，而是在每次有新的元素需要添加时再来动态请求内存空间，因此 LinkedList 的两个构造函数都很简单
//当使用空参构造初始化之后,first last size 都已经存在了,只不过是默认初始化值
public LinkedList() {
}
//传入初始数据
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
4.添加元素
add(E e) 方法用于向链表的尾部添加结点，因为有 last 指向链表的尾结点，因此向尾部添加新元素只需要修改几个引用即可，效率较高
大致逻辑:
- 先创建一个变量 l 用于保存原尾结点last,
- 然后创建一个新的尾节点newNode,并将其指向其原来的尾节点last
- 将新的尾节点newNode指向 原来的尾节点last
- 判断如果原尾节点变量 l 为空,说明原来链表的个数尾0,此时插入的尾节点同时设置为头节点
- 如果不为空,则将next指向新的尾节点 newNode
//将元素 e 作为尾结点添加
//因为 LinkedList 允许添加相同元素，所以此方法固定返回 true
public boolean add(E e) {
linkLast(e);
return true;
}
//将元素 e 置为尾结点
void linkLast(E e) {
//先保存原尾结点
final Node<E> l = last;
//构建新的尾结点，并指向原尾结点
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
//如果原尾结点为 null，说明原链表包含的元素个数为 0，则此时插入的尾结点同时即为头结点
//如果原尾结点不为 null，则将 next 指向新的尾结点
if (l == null)
first = newNode;
else
l.next = newNode;
//元素个数加1
size++;
modCount++;
}
add(int index, E element) 方法用于向指定索引处添加元素，需要先通过索引 index 获取相应位置的结点，并在该位置开辟一个新的结点来存储元素 element，最后还需要修改相邻结点间的引用
//在索引 index 处插入元素 element
public void add(int index, E element) {
//判断索引大小是否合法，不合法则抛出 IndexOutOfBoundsException
checkPositionIndex(index);
//如果 index == size，则将 element 作为尾结点来添加
//否则则在索引 index 前开辟一个新结点
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
//将元素 e 置为 succ 结点的上一个结点
void linkBefore(E e, Node<E> succ) {
//保存 succ 的上一个结点信息
final Node<E> pred = succ.prev;
//构建元素 e 对应的结点
final Node<E> newNode = new Node<>(pred, e, succ);
//将结点 succ 的上一个结点指向 newNode
succ.prev = newNode;
//如果 pred 为 null，说明 succ 是头结点，则将 newNode 置为新的头结点
if (pred == null)
first = newNode;
else
pred.next = newNode;
//元素个数加1
size++;
modCount++;
}
5.移除元素
remove() 方法有两种重载形式，其内部都是通过调用 unlink(Node x) 方法来移除指定结点在链表中的引用，不同于 ArrayList 在移除元素时可能导致的大量数据移动，LinkedList 只需要通过移除引用即可将指定元素从链表中移除
//移除索引 index 处的结点
public E remove(int index) {
//判断索引大小是否合法，不合法则抛出 IndexOutOfBoundsException
checkElementIndex(index);
return unlink(node(index));
}
//对链表进行正向遍历，移除第一个元素值为 o 的结点
//如果移除成功则返回 true，否则返回 false
public boolean remove(Object o) {
if (o == null) {
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null) {
//移除结点 x
unlink(x);
return true;
}
}
} else {
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item)) {
//移除结点 x
unlink(x);
return true;
}
}
}
return false;
}
//移除结点 x 并返回其包含的元素值
E unlink(Node<E> x) {
final E element = x.item;
final Node<E> next = x.next;
final Node<E> prev = x.prev;
//如果 prev == null，说明结点 x 为头结点，则将头结点置为原先的第二个结点
//如果 prev != null，则移除对结点 x 的引用
if (prev == null) {
first = next;
} else {
prev.next = next;
x.prev = null;
}
//如果 next == null，则说明结点 x 为尾结点，则将尾结点置为原先的倒数第二个结点
//如果 next != null，则移除对结点 x 的引用
if (next == null) {
last = prev;
} else {
next.prev = prev;
x.next = null;
}
//帮助GC回收
x.item = null;
//元素个数减1
size--;
modCount++;
return element;
}
6.Deque接口
Deque 接口中很多方法的含义都是类似的，且一些方法都是相互调用的，并不算复杂
//将元素 e 置为头结点
public void addFirst(E e) {
linkFirst(e);
}
//将元素 e 置为尾结点
public void addLast(E e) {
linkLast(e);
}
//将元素 e 作为尾结点添加
public boolean offer(E e) {
return add(e);
}
//将元素 e 作为头结点添加
public boolean offerFirst(E e) {
addFirst(e);
return true;
}
//将元素 e 作为尾结点添加
public boolean offerLast(E e) {
addLast(e);
return true;
}
//获取头部结点的元素值
public E peekFirst() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
//获取尾部结点的元素值
public E peekLast() {
final Node<E> l = last;
return (l == null) ? null : l.item;
}
//获取头部结点的元素值，并将之从链表中移除
public E pollFirst() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
//获取尾部结点的元素值，并将之从链表中移除
public E pollLast() {
final Node<E> l = last;
return (l == null) ? null : unlinkLast(l);
}
//将元素 e 作为头结点添加
public void push(E e) {
addFirst(e);
}
//获取头部结点的元素值，并将之从链表中移除
public E pop() {
return removeFirst();
}
//从链表头部向尾部正向遍历，移除第一个元素值为 o 的结点
//如果移除成功则返回 true，否则返回 false
public boolean removeFirstOccurrence(Object o) {
return remove(o);
}
//从链表尾部向头部反向遍历，移除第一个元素值为 o 的结点
//如果移除成功则返回 true，否则返回 false
public boolean removeLastOccurrence(Object o) {
if (o == null) {
for (Node<E> x = last; x != null; x = x.prev) {
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
for (Node<E> x = last; x != null; x = x.prev) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
}
1460
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
