0
点赞
收藏
分享

微信扫一扫

聊聊 Java 和 Android 的集合框架(第一回)

是她丫 2022-04-27 阅读 94
经验分享

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++;

}

复制代码

以上说的是存入单个数据的情况,此外还有存入整个集合的情况

//如果待添加的数据不为空则返回 true,否则返回 false

public boolean addAll(Collection<? extends E> c) {

Object[] a = c.toArray();

int numNew = a.length;

ensureCapacityInternal(size + numNew);

//将数组 a 复制到 elementData 的尾端

System.arraycopy(a, 0, elementData, size, numNew);

size += numNew;

return numNew != 0;

}

//从指定索引处添加数据,如果待添加的数据不为空则返回 true,否则返回 false

public boolean addAll(int index, Collection<? extends E> c) {

rangeCheckForAdd(index);

Object[] a = c.toArray();

int numNew = a.length;

ensureCapacityInternal(size + numNew);

//需要移动的数组元素数量

int numMoved = size - index;

//因为要添加的数据可能刚好是从数组最尾端开始添加,所以 numMoved 可能为 0

//所以只在 numMoved > 0 的时候才需要对数组的元素值进行移动,以此空出位置给数组 a

if (numMoved > 0)

System.arraycopy(elementData, index, elementData, index + numNew, numMoved);

//将数组 a 包含的数据添加到 elementData 中

System.arraycopy(a, 0, elementData, index, numNew);

size += numNew;

return numNew != 0;

}

复制代码

[](()6、移除元素

因为数组是一种内存地址连续的数据结构,所以移除某个元素同样可能导致大量元素移动

//移除指定索引处的元素值,并返回该值

public E remove(int index) {

rangeCheck(index);

modCount++;

//待移除的元素值

E oldValue = elementData(index);

//因为要移除元素导致需要移动的元素数量

int numMoved = size - index - 1;

//因为要移除的元素可能刚好是数组最后一位,所以 numMoved 可能为 0

//所以只在 numMoved > 0 的时候才需要对 《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》无偿开源 徽信搜索公众号【编程进阶路】 数组的元素值进行移动

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;

}

复制代码

[](()7、扩容机制

再来看下数组的扩容机制的具体实现逻辑

ensureCapacity 方法的入参参数 minCapacity 就用于指定希望扩容后的最小空间,但 minCapacity 最终不会小于 DEFAULT_CAPACITY,即扩容后的数组容量不会小于 10。之所以要进行最小容量的限制,是为了减少多次扩容的可能性,十以内的数组很容易就发生扩容

如果在初始化 ArrayList 前已知目标数据的数据量,最好就使用ArrayList(int initialCapacity)来进行初始化,直接让底层数组扩充到目标大小,或者是在添加数据前就调用 ensureCapacity 方法直接让数组扩容到目标大小,避免之后赋值过程中多次扩容

public void ensureCapacity(int minCapacity) {

int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)

? 0
DEFAULT_CAPACITY;

if (minCapacity > minExpand) {

ensureExplicitCapacity(minCapacity);

}

}

private void ensureCapacityInternal(int minCapacity) {

if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {

minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);

}

ensureExplicitCapacity(minCapacity);

}

private void ensureExplicitCapacity(int minCapacity) {

modCount++;

//如果当前数组大小的确是比需要的最小空间 minCapacity 小,则进行扩容

if (minCapacity - elementData.length > 0)

grow(minCapacity);

}

复制代码

实际上完成扩容操作的是 grow(int minCapacity) 方法。在扩容前,会先判断如果将容量提升到当前的 1.5 倍是否能达到 minCapacity 的要求 ,如果符合要求则直接将容量扩充到当前的 1.5 倍,否则扩充到 minCapacity,但最终容量不能大于 Integer.MAX_VALUE

构建出一个新的符合大小的数组后,就将原数组中的元素复制到新数组中,至此就完成了扩容

//数组可扩容到的最大容量

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

private void grow(int minCapacity) {

int oldCapacity = elementData.length;

//假设扩容后的空间大小是原先的1.5倍

int newCapacity = oldCapacity + (oldCapacity >> 1);

if (newCapacity - minCapacity < 0)

newCapacity = minCapacity;

if (newCapacity - MAX_ARRAY_SIZE > 0)

newCapacity = hugeCapacity(minCapacity);

elementData = Arrays.copyOf(elementData, newCapacity);

}

复制代码

[](()8、修改元素

//将索引 index 出的元素值置为 element,并返回原始数值

public E set(int index, E element) {

rangeCheck(index);

E oldValue = elementData(index);

elementData[index] = element;

return oldValue;

}

复制代码

[](()9、遍历数组

遍历数组的方法包含以下几个,逻辑都比较简单,直接看注释即可。一个比较重要的知识点是看方法内部对 modCount 的校验

@Override

public void forEach(Consumer<? super E> action) {

Objects.requireNonNull(action);

final int expectedModCount = modCount;

@SuppressWarnings(“unchecked”)

final E[] elementData = (E[]) this.elementData;

final int size = this.size;

for (int i=0; modCount == expectedModCount && i < size; i++) {

//将集合元素依次传递给 accept 方法

action.accept(elementData[i]);

}

//如果 modCount 值被改动了,说明遍历过程中数组有被改动到

//那么就停止遍历并抛出异常

if (modCount != expectedModCount) {

throw new ConcurrentModificationException();

}

}

//按照给定规则对集合元素进行过滤,如果元素符合过滤规则那就将之移除

@Override

public boolean removeIf(Predicate<? super E> filter) {

Objects.requireNonNull(filter);

//要移除的元素个数

int removeCount = 0;

//用于标记集合是哪个索引位置需要被移除

final BitSet removeSet = new BitSet(size);

final int expectedModCount = modCount;

final int size = this.size;

for (int i=0; modCount == expectedModCount && i < size; i++) {

@SuppressWarnings(“unchecked”)

final E element = (E) elementData[i];

//依次判断集合元素是否符合过滤规则

if (filter.test(element)) {

//set 方法将导致索引位置 i 的元素变为 true

removeSet.set(i);

removeCount++;

}

}

//不允许在排序的过程中集合被其它方法修改了数组(例如:移除元素)

if (modCount != expectedModCount) {

throw new ConcurrentModificationException();

}

//只有 removeCount > 0 才说明需要移除元素

final boolean anyToRemove = removeCount > 0;

if (anyToRemove) {

//集合移除指定元素后的大小

final int newSize = size - removeCount;

for (int i=0, j=0; (i < size) && (j < newSize); i++, j++) {

//略过被标记为 true 的位置,直接跳到不需要移除元素的数组索引位

i = removeSet.nextClearBit(i);

//有效数据逐渐从尾部向头部聚集

elementData[j] = elementData[i];

}

//移除尾部的无效数据,有利于GC回收

for (int k=newSize; k < size; k++) {

elementData[k] = null;

}

this.size = newSize;

//不允许在排序的过程中集合被其它方法修改了数组(例如:移除元素)

if (modCount != expectedModCount) {

throw new ConcurrentModificationException();

}

modCount++;

}

return anyToRemove;

}

//将集合元素遍历传递给 operator,并将原始数据替换为 operator 的返回值

@Override

@SuppressWarnings(“unchecked”)

public void replaceAll(UnaryOperator operator) {

Objects.requireNonNull(operator);

final int expectedModCount = modCount;

final int size = this.size;

for (int i=0; modCount == expectedModCount && i < size; i++) {

//依次传递数组元素给 apply 方法,并将其返回值替换原始数据

elementData[i] = operator.apply((E) elementData[i]);

}

//不允许在排序的过程中集合被其它方法修改了数组(例如:移除元素)

if (modCount != expectedModCount) {

throw new ConcurrentModificationException();

}

modCount++;

}

复制代码

[](()10、迭代器

ArrayList 内部包含一个用于迭代元素的 Iterator 实现类,其用法如下所示

public static void main(String[] args) {

List stringList = new ArrayList<>();

stringList.add(“https://github.com/leavesC”);

Iterator iterator = stringList.iterator();

if (iterator.hasNext()) {

String next = iterator.next();

System.out.println(next);

}

}

复制代码

在这里有个小细节,ArrayList 里多处使用到了 modCount 这个成员变量,modCount 相当于对 ArrayList 的一个简单“快照”,即类似于 ArrayList 的一个版本号,每当添加、移除和修改元素时,modCount 都会递增

在我们遍历 ArrayList 的过程中,如果同时进行增减元素的操作,或者是存在多线程同时增减元素,那么就会导致遍历结果变得不可靠,或者是直接就导致数组越界异常,所以 ArrayList 就通过 modCount 来标记当前的迭代行为是否处于可靠状态。如果在在遍历数组元素的过程中判断到 modCount 的值前后发生了变化,就说明在遍历过程中 ArrayList 被改动了,此时就认定遍历结果不可靠,直接抛出异常。但需要注意的是,modCount 做的只是一个简单校验,无法准备判断出当前的遍历操作就真的是安全的

protected transient int modCount = 0;

public Iterator iterator() {

return new Itr();

}

private class Itr implements Iterator {

//lastRet 指向的元素的下一个元素的索引

int cursor;

//最后一个返回的元素的索引

//如果值为 -1,说明还未返回过元素或者改元素被移除了

int lastRet = -1;

//用于验证集合的数据结构在迭代的过程中是否被修改了

int expectedModCount = modCount;

//是否还有元素未被遍历

public boolean hasNext() {

return cursor != size;

}

//获取下一个元素

@SuppressWarnings(“unchecked”)

public E next() {

checkForComodification();

int i = cursor;

//如果索引值超出取值范围则抛出异常

if (i >= size)

throw new NoSuchElementException();

Object[] elementData = ArrayList.this.elementData;

//如果索引值超出数组的可索引范围则抛出异常

if (i >= elementData.length)

throw new ConcurrentModificationException();

cursor = i + 1;

return (E) elementData[lastRet = i];

}

//移除 lastRet 指向的元素

public void remove() {

if (lastRet < 0)

throw new IllegalStateException();

checkForComodification();

try {

ArrayList.this.remove(lastRet);

//因为 lastRet 位置原始的元素被移除了,所以此时 lastRet 指向的元素是原先 lastRet+1 位置的元素

cursor = lastRet;

lastRet = -1;

//因为是 Itr 主动对集合进行修改,所以此处需要主动更新 expectedModCount 值,避免之后抛出异常

expectedModCount = modCount;

} catch (IndexOutOfBoundsException ex) {

throw new ConcurrentModificationException();

}

}

//遍历从索引 cursor 开始之后剩下的元素

@Override

@SuppressWarnings(“unchecked”)

public void forEachRemaining(Consumer<? super E> consumer) {

Objects.requireNonNull(consumer);

final int size = ArrayList.this.size;

int i = cursor;

if (i >= size) {

return;

}

final Object[] elementData = ArrayList.this.elementData;

if (i >= elementData.length) {

throw new ConcurrentModificationException();

}

//遍历调用 accept 方法

while (i != size && modCount == expectedModCount) {

consumer.accept((E) elementData[i++]);

}

cursor = i;

lastRet = i - 1;

checkForComodification();

}

//判断迭代器在遍历集合的过程中,集合是否被外部改动了(例如被其它迭代器移除了元素)

//如果是的话则抛出异常

final void checkForComodification() {

if (modCount != expectedModCount)

throw new ConcurrentModificationException();

}

}

复制代码

[](()11、效率测试

最后再来测试下 ArrayList 扩容次数的高低对其运行效率的影响

对三个 ArrayList 存入相同数据量的数据,但分别为 ArrayList 指定不同的初始化大小

public static void main(String[] args) {

long startTime = System.currentTimeMillis();

List stringList = new ArrayList<>();

for (int i = 0; i < 300000; i++) {

stringList.add("leavesC " + i);

}

long endTime = System.currentTimeMillis();

System.out.println(“初始容量为0,所用时间:” + (endTime - startTime) + “毫秒”);

startTime = System.currentTimeMillis();

List stringList2 = new ArrayList<>(100000);

for (int i = 0; i < 300000; i++) {

stringList2.add("leavesC " + i);

}

endTime = System.currentTimeMillis();

System.out.println(“初始容量为100000,所用时间:” + (endTime - startTime) + “毫秒”);

startTime = System.currentTimeMillis();

List stringList3 = new ArrayList<>(300000);

for (int i = 0; i < 300000; i++) {

stringList3.add("leavesC " + i);

}

endTime = System.currentTimeMillis();

System.out.println(“初始容量为300000,所用时间:” + (endTime - startTime) + “毫秒”);

}

复制代码

三种方式下 ArrayList 之间的运行效率差距还是很大的,虽然这种测试方法并不严谨,但也可以看到在省去扩容操作后 ArrayList 的运行效率还是提升了很多的

初始容量为0,所用时间:39毫秒

初始容量为100000,所用时间:32毫秒

初始容量为300000,所用时间:13毫秒

复制代码

[](()三、LinkedList


LinkedList 同时实现了 List 接口和 Deque 接口,所以既可以将 LinkedList 当做一个有序容器,也可以将之看作一个队列(Queue),同时又可以看作一个栈(Stack)。虽然 LinkedList 和 ArrayList 一样都实现了 List 接口,但其底层是通过双向链表来实现的,所以插入和删除元素的效率都要比 ArrayList 高,但也因此随机访问的效率要比 ArrayList 低

[](()1、类声明

从 LinkedList 实现的几个接口可以看出来,LinkedList 是支持快速访问,可克隆,可序列化的,而且可以将之看成一个支持有序访问的队列或者栈

public class LinkedList extends AbstractSequentialList implements List, Deque, Cloneable, java.io.Serializable

复制代码

LinkedList 内部通过双向链表的数据结构来实现的,每个链表结点除了存储本结点的数据元素外,还有两个指针分别用于指向其上下两个相邻结点,这个结点就是 LinkedList 中的静态类 Node

private static class Node {

//当前结点包含的实际元素

E item;

//指向下一个结点

Node next;

//指向上一个结点

Node prev;

Node(Node prev, E element, Node next) {

this.item = element;

this.next = next;

this.prev = prev;

}

}

复制代码

[](()2、成员变量

//双向链表包含的结点总数,即数据总量

transient int size = 0;

//双向链表的头结点

transient Node first;

//双向链表的尾结点

transient Node last;

//序列化ID

private static final long serialVersionUID = 876323262645176354L;

复制代码

当中的成员变量 first 和 last 分别用于指向链表的头部和尾部结点,因此 LinkedList 的数据结构图是类似于这样的

[](()3、构造函数

LinkedList 不需要去请求一片连续的内存空间来存储数据,而是在每次有新的元素需要添加时再来动态请求内存空间,因此 LinkedList 的两个构造函数都很简单

public LinkedList() {

}

//传入初始数据

public LinkedList(Collection<? extends E> c) {

this();

addAll©;

}

复制代码

[](()4、添加元素

add(E e) 方法用于向链表的尾部添加结点,因为有 last 指向链表的尾结点,因此向尾部添加新元素只需要修改几个引用即可,效率较高

//将元素 e 作为尾结点添加

//因为 LinkedList 允许添加相同元素,所以此方法固定返回 true

public boolean add(E e) {

linkLast(e);

return true;

}

//将元素 e 置为尾结点

void linkLast(E e) {

//先保存原尾结点

final Node l = last;

//构建新的尾结点,并指向原尾结点

final Node 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 succ) {

//保存 succ 的上一个结点信息

final Node pred = succ.prev;

//构建元素 e 对应的结点

final Node 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<E> 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 x = first; x != null; x = x.next) {

if (x.item == null) {

//移除结点 x

unlink(x);

return true;

}

}

} else {

for (Node x = first; x != null; x = x.next) {

if (o.equals(x.item)) {

//移除结点 x

unlink(x);

return true;

}

}

}

return false;

}

//移除结点 x 并返回其包含的元素值

E unlink(Node x) {

final E element = x.item;

final Node next = x.next;

final Node 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、随机访问元素

对于单向链表来说,如果想随机定位到某个结点,那么只能通过从头结点开始遍历的方式来定位,最极端的情况下需要遍历整个链表才能定位到目标结点。如果是双向链表,则可以选择正向遍历或者反向遍历,最极端的情况下需要遍历一半链表才能定位到目标结点。所以,相比数组来说,LinkedList 的随机访问效率并不高

举报

相关推荐

0 条评论