JavaSE （六）集合类与IO
AI-摘要
Tianli GPT
AI初始化中...
介绍自己
生成本文简介
推荐相关文章
前往主页
前往tianli博客
集合类与IO
前面我们已经把基础介绍完了，从这节课开始，我们就正式进入到集合类的讲解中。
集合类
集合类是Java中非常重要的存在，使用频率极高。集合其实与我们数学中的集合是差不多的概念，集合表示一组对象，每一个对象我们都可以称其为元素。不同的集合有着不同的性质，比如一些集合允许重复的元素，而另一些则不允许，一些集合是有序的，而其他则是无序的。
集合类其实就是为了更好地组织、管理和操作我们的数据而存在的，包括列表、集合、队列、映射等数据结构。从这一块开始，我们会从源码角度给大家讲解（先从接口定义对于集合需要实现哪些功能开始说起，包括这些集合类的底层机制是如何运作的）不仅仅是教会大家如何去使用。
集合跟数组一样，可以表示同样的一组元素，但是他们的相同和不同之处在于：
- 它们都是容器，都能够容纳一组元素。
不同之处：
- 数组的大小是固定的，集合的大小是可变的。
- 数组可以存放基本数据类型，但集合只能存放对象。
- 数组存放的类型只能是一种，但集合可以有不同种类的元素。
集合根接口
Java中已经帮我们将常用的集合类型都实现好了，我们只需要直接拿来用就行了，比如我们之前学习的顺序表：
import java.util.ArrayList; //集合类基本都是在java.util包下定义的
public class Main {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("树脂666");
}
}
当然，我们会在这一部分中认识大部分Java为我们提供的集合类。所有的集合类最终都是实现自集合根接口的，比如我们下面就会讲到的ArrayList类，它的祖先就是Collection接口：
这个接口定义了集合类的一些基本操作，我们来看看有哪些方法：
public interface Collection<E> extends Iterable<E> {
//-------这些是查询相关的操作----------
//获取当前集合中的元素数量
int size();
//查看当前集合是否为空
boolean isEmpty();
//查询当前集合中是否包含某个元素
boolean contains(Object o);
//返回当前集合的迭代器，我们会在后面介绍
Iterator<E> iterator();
//将集合转换为数组的形式
Object[] toArray();
//支持泛型的数组转换，同上
<T> T[] toArray(T[] a);
//-------这些是修改相关的操作----------
//向集合中添加元素，不同的集合类具体实现可能会对插入的元素有要求，
//这个操作并不是一定会添加成功，所以添加成功返回true，否则返回false
boolean add(E e);
//从集合中移除某个元素，同样的，移除成功返回true，否则false
boolean remove(Object o);
//-------这些是批量执行的操作----------
//查询当前集合是否包含给定集合中所有的元素
//从数学角度来说，就是看给定集合是不是当前集合的子集
boolean containsAll(Collection<?> c);
//添加给定集合中所有的元素
//从数学角度来说，就是将当前集合变成当前集合与给定集合的并集
//添加成功返回true，否则返回false
boolean addAll(Collection<? extends E> c);
//移除给定集合中出现的所有元素，如果某个元素在当前集合中不存在，那么忽略这个元素
//从数学角度来说，就是求当前集合与给定集合的差集
//移除成功返回true，否则false
boolean removeAll(Collection<?> c);
//Java8新增方法，根据给定的Predicate条件进行元素移除操作
default boolean removeIf(Predicate<? super E> filter) {
Objects.requireNonNull(filter);
boolean removed = false;
final Iterator<E> each = iterator(); //这里用到了迭代器，我们会在后面进行介绍
while (each.hasNext()) {
if (filter.test(each.next())) {
each.remove();
removed = true;
}
}
return removed;
}
//只保留当前集合中在给定集合中出现的元素，其他元素一律移除
//从数学角度来说，就是求当前集合与给定集合的交集
//移除成功返回true，否则false
boolean retainAll(Collection<?> c);
//清空整个集合，删除所有元素
void clear();
//-------这些是比较以及哈希计算相关的操作----------
//判断两个集合是否相等
boolean equals(Object o);
//计算当前整个集合对象的哈希值
int hashCode();
//与迭代器作用相同，但是是并行执行的，我们会在下一章多线程部分中进行介绍
@Override
default Spliterator<E> spliterator() {
return Spliterators.spliterator(this, 0);
}
//生成当前集合的流，我们会在后面进行讲解
default Stream<E> stream() {
return StreamSupport.stream(spliterator(), false);
}
//生成当前集合的并行流，我们会在下一章多线程部分中进行介绍
default Stream<E> parallelStream() {
return StreamSupport.stream(spliterator(), true);
}
}
可以看到，在这个接口中对于集合相关的操作，还是比较齐全的，那么我们接着就来看看它的实现类。
List列表
首先我们需要介绍的是List列表（线性表），线性表支持随机访问，相比之前的Collection接口定义，功能还会更多一些。首先介绍ArrayList，我们已经知道，它的底层是用数组实现的，内部维护的是一个可动态进行扩容的数组，也就是我们之前所说的顺序表，跟我们之前自己写的ArrayList相比，它更加的规范，并且功能更加强大，同时实现自List接口。
List是集合类型的一个分支，它的主要特性有：
- 是一个有序的集合，插入元素默认是插入到尾部，按顺序从前往后存放，每个元素都有一个自己的下标位置
- 列表中允许存在重复元素
在List接口中，定义了列表类型需要支持的全部操作，List直接继承自前面介绍的Collection接口，其中很多地方重新定义了一次Collection接口中定义的方法，这样做是为了更加明确方法的具体功能，当然，为了直观，我们这里就省略掉：
//List是一个有序的集合类，每个元素都有一个自己的下标位置
//List中可插入重复元素
//针对于这些特性，扩展了Collection接口中一些额外的操作
public interface List<E> extends Collection<E> {
...
//将给定集合中所有元素插入到当前结合的给定位置上（后面的元素就被挤到后面去了，跟我们之前顺序表的插入是一样的）
boolean addAll(int index, Collection<? extends E> c);
...
//Java 8新增方法，可以对列表中每个元素都进行处理，并将元素替换为处理之后的结果
default void replaceAll(UnaryOperator<E> operator) {
Objects.requireNonNull(operator);
final ListIterator<E> li = this.listIterator(); //这里同样用到了迭代器
while (li.hasNext()) {
li.set(operator.apply(li.next()));
}
}
//对当前集合按照给定的规则进行排序操作，这里同样只需要一个Comparator就行了
@SuppressWarnings({"unchecked", "rawtypes"})
default void sort(Comparator<? super E> c) {
Object[] a = this.toArray();
Arrays.sort(a, (Comparator) c);
ListIterator<E> i = this.listIterator();
for (Object e : a) {
i.next();
i.set((E) e);
}
}
...
//-------- 这些是List中独特的位置直接访问操作 --------
//获取对应下标位置上的元素
E get(int index);
//直接将对应位置上的元素替换为给定元素
E set(int index, E element);
//在指定位置上插入元素，就跟我们之前的顺序表插入是一样的
void add(int index, E element);
//移除指定位置上的元素
E remove(int index);
//------- 这些是List中独特的搜索操作 -------
//查询某个元素在当前列表中的第一次出现的下标位置
int indexOf(Object o);
//查询某个元素在当前列表中的最后一次出现的下标位置
int lastIndexOf(Object o);
//------- 这些是List的专用迭代器 -------
//迭代器我们会在下一个部分讲解
ListIterator<E> listIterator();
//迭代器我们会在下一个部分讲解
ListIterator<E> listIterator(int index);
//------- 这些是List的特殊转换 -------
//返回当前集合在指定范围内的子集
List<E> subList(int fromIndex, int toIndex);
...
}
可以看到，在List接口中，扩展了大量列表支持的操作，其中最突出的就是直接根据下标位置进行的增删改查操作。而在ArrayList中，底层就是采用数组实现的，跟我们之前的顺序表思路差不多：
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
//默认的数组容量
private static final int DEFAULT_CAPACITY = 10;
...
//存放数据的底层数组，这里的transient关键字我们会在后面I/O中介绍用途
transient Object[] elementData;
//记录当前数组元素数的
private int size;
//这是ArrayList的其中一个构造方法
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 boolean add(E e) {
ensureCapacityInternal(size + 1); // 这里会判断容量是否充足，不充足需要扩容
elementData[size++] = e;
return true;
}
...
//默认的列表最大长度为Integer.MAX_VALUE - 8
//JVM都C++实现中，在数组的对象头中有一个_length字段，用于记录数组的长
//度，所以这个8就是存了数组_length字段（这个只做了解就行）
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1); //扩容规则跟我们之前的是一样的，也是1.5倍
if (newCapacity - minCapacity < 0) //要是扩容之后的大小还没最小的大小大，那么直接扩容到最小的大小
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0) //要是扩容之后比最大的大小还大，需要进行大小限制
newCapacity = hugeCapacity(minCapacity); //调整为限制的大小
elementData = Arrays.copyOf(elementData, newCapacity); //使用copyOf快速将内容拷贝到扩容后的新数组中并设定为新的elementData底层数组
}
}
一般的，如果我们要使用一个集合类，我们会使用接口的引用：
public static void main(String[] args) {
List<String> list = new ArrayList<>(); //使用接口的引用来操作具体的集合类实现，是为了方便日后如果我们想要更换不同的集合类实现，而且接口中本身就已经定义了主要的方法，所以说没必要直接用实现类
list.add("科技与狠活"); //使用add添加元素
list.add("上头啊");
System.out.println(list); //打印集合类，可以得到一个非常规范的结果
}
可以看到，打印集合类的效果，跟我们使用Arrays工具类是一样的：
集合的各种功能我们都可以来测试一下，特别注意一下，我们在使用Integer时，要注意传参问题：
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(10); //添加Integer的值10
list.remove((Integer) 10); //注意，不能直接用10，默认情况下会认为传入的是int类型值，删除的是下标为10的元素，我们这里要删除的是刚刚传入的值为10的Integer对象
System.out.println(list); //可以看到，此时元素成功被移除
}
那要是这样写呢？
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(new Integer(10)); //添加的是一个对象
list.remove(new Integer(10)); //删除的是另一个对象
System.out.println(list);
}
可以看到，结果依然是删除成功，这是因为集合类在删除元素时，只会调用equals方法进行判断是否为指定元素，而不是进行等号判断，所以说一定要注意，如果两个对象使用equals方法相等，那么集合中就是相同的两个对象：
//ArrayList源码部分
public boolean remove(Object o) {
if (o == null) {
...
} else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) { //这里只是对两个对象进行equals判断
fastRemove(index);
return true; //只要判断成功，直接认为就是要删除的对象，删除就完事
}
}
return false;
}
列表中允许存在相同元素，所以说我们可以添加两个一模一样的：
public static void main(String[] args) {
List<String> list = new ArrayList<>();
String str = "哟唉嘛干你";
list.add(str);
list.add(str);
System.out.println(list);
}
那要是此时我们删除对象呢，是一起删除还是只删除一个呢？
public static void main(String[] args) {
List<String> list = new ArrayList<>();
String str = "哟唉嘛干你";
list.add(str);
list.add(str);
list.remove(str);
System.out.println(list);
}
可以看到，这种情况下，只会删除排在前面的第一个元素。
集合类是支持嵌套使用的，一个集合中可以存放多个集合，套娃嘛，谁不会：
public static void main(String[] args) {
List<List<String>> list = new LinkedList<>();
list.add(new LinkedList<>()); //集合中的每一个元素就是一个集合，这个套娃是可以一直套下去的
System.out.println(list.get(0).isEmpty());
}
在Arrays工具类中，我们可以快速生成一个只读的List：
public static void main(String[] args) {
List<String> list = Arrays.asList("A", "B", "C"); //非常方便
System.out.println(list);
}
注意，这个生成的List是只读的，不能进行修改操作，只能使用获取内容相关的方法，否则抛出 UnsupportedOperationException 异常。要生成正常使用的，我们可以将这个只读的列表作为参数传入：
public static void main(String[] args) {
List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));
System.out.println(list);
}
当然，也可以利用静态代码块：
public static void main(String[] args) {
List<String> list = new ArrayList<String>() {{ //使用匿名内部类（匿名内部类在Java8无法使用钻石运算符，但是之后的版本可以）
add("A");
add("B");
add("C");
}};
System.out.println(list);
}
这里我们接着介绍另一个列表实现类，LinkedList同样是List的实现类，只不过它是采用的链式实现，也就是我们之前讲解的链表，只不过它是一个双向链表，也就是同时保存两个方向：
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
transient int size = 0;
//引用首结点
transient Node<E> first;
//引用尾结点
transient Node<E> last;
//构造方法，很简单，直接创建就行了
public LinkedList() {
}
...
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;
}
}
...
}
LinkedList的使用和ArrayList的使用几乎相同，各项操作的结果也是一样的，在什么使用使用ArrayList和LinkedList，我们需要结合具体的场景来决定，尽可能的扬长避短。
只不过LinkedList不仅可以当做List来使用，也可以当做双端队列使用，我们会在后面进行详细介绍。
迭代器
我们接着来介绍迭代器，实际上我们的集合类都是支持使用foreach语法的：
public static void main(String[] args) {
List<String> list = Arrays.asList("A", "B", "C");
for (String s : list) { //集合类同样支持这种语法
System.out.println(s);
}
}
但是由于仅仅是语法糖，实际上编译之后：
public static void main(String[] args) {
List<String> list = Arrays.asList("A", "B", "C");
Iterator var2 = list.iterator(); //这里使用的是List的迭代器在进行遍历操作
while(var2.hasNext()) {
String s = (String)var2.next();
System.out.println(s);
}
}
那么这个迭代器是一个什么东西呢？我们来研究一下：
public static void main(String[] args) {
List<String> list = Arrays.asList("A", "B", "C");
//通过调用iterator方法快速获取当前集合的迭代器
//Iterator迭代器本身也是一个接口，由具体的集合实现类来根据情况实现
Iterator<String> iterator = list.iterator();
}
通过使用迭代器，我们就可以实现对集合中的元素的进行遍历，就像我们遍历数组那样，它的运作机制大概是：
一个新的迭代器就像上面这样，默认有一个指向集合中第一个元素的指针：
每一次next操作，都会将指针后移一位，直到完成每一个元素的遍历，此时再调用next将不能再得到下一个元素。至于为什么要这样设计，是因为集合类的实现方案有很多，可能是链式存储，也有可能是数组存储，不同的实现有着不同的遍历方式，而迭代器则可以将多种多样不同的集合类遍历方式进行统一，只需要各个集合类根据自己的情况进行对应实现就行了。
我们来看看这个接口的源码定义了哪些操作：
public interface Iterator<E> {
//看看是否还有下一个元素
boolean hasNext();
//遍历当前元素，并将下一个元素作为待遍历元素
E next();
//移除上一个被遍历的元素（某些集合不支持这种操作）
default void remove() {
throw new UnsupportedOperationException("remove");
}
//对剩下的元素进行自定义遍历操作
default void forEachRemaining(Consumer<? super E> action) {
Objects.requireNonNull(action);
while (hasNext())
action.accept(next());
}
}
在ArrayList和LinkedList中，迭代器的实现也不同，比如ArrayList就是直接按下标访问：
public E next() {
...
cursor = i + 1; //移动指针
return (E) elementData[lastRet = i]; //直接返回指针所指元素
}
LinkedList就是不断向后寻找结点：
public E next() {
...
next = next.next; //向后继续寻找结点
nextIndex++;
return lastReturned.item; //返回结点内部存放的元素
}
虽然这两种列表的实现不同，遍历方式也不同，但是都是按照迭代器的标准进行了实现，所以说，我们想要遍历一个集合中所有的元素，那么就可以直接使用迭代器来完成，而不需要关心集合类是如何实现，我们该怎么去遍历：
public static void main(String[] args) {
List<String> list = Arrays.asList("A", "B", "C");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) { //每次循环一定要判断是否还有元素剩余
System.out.println(iterator.next()); //如果有就可以继续获取到下一个元素
}
}
注意，迭代器的使用是一次性的，用了之后就不能用了，如果需要再次进行遍历操作，那么需要重新生成一个迭代器对象。为了简便，我们可以直接使用foreach语法来快速遍历集合类，效果是完全一样的：
public static void main(String[] args) {
List<String> list = Arrays.asList("A", "B", "C");
for (String s : list) {
System.out.println(s);
}
}
在Java8提供了一个支持Lambda表达式的forEach方法，这个方法接受一个Consumer，也就是对遍历的每一个元素进行的操作：
public static void main(String[] args) {
List<String> list = Arrays.asList("A", "B", "C");
list.forEach(System.out::println);
}
这个效果跟上面的写法是完全一样的，因为forEach方法内部本质上也是迭代器在处理，这个方法是在Iterable接口中定义的：
default void forEach(Consumer<? super T> action) {
Objects.requireNonNull(action);
for (T t : this) { //foreach语法遍历每一个元素
action.accept(t); //调用Consumer的accept来对每一个元素进行消费
}
}
那么我们来看一下，Iterable这个接口又是是什么东西？
我们来看看定义了哪些内容：
//注意这个接口是集合接口的父接口，不要跟之前的迭代器接口搞混了
public interface Iterable<T> {
//生成当前集合的迭代器，在Collection接口中重复定义了一次
Iterator<T> iterator();
//Java8新增方法，因为是在顶层接口中定义的，因此所有的集合类都有这个方法
default void forEach(Consumer<? super T> action) {
Objects.requireNonNull(action);
for (T t : this) {
action.accept(t);
}
}
//这个方法会在多线程部分中进行介绍，暂时不做讲解
default Spliterator<T> spliterator() {
return Spliterators.spliteratorUnknownSize(iterator(), 0);
}
}
得益于Iterable提供的迭代器生成方法，实际上只要是实现了迭代器接口的类（我们自己写的都行），都可以使用foreach语法：
public class Test implements Iterable<String>{ //这里我们随便写一个类，让其实现Iterable接口
@Override
public Iterator<String> iterator() {
return new Iterator<String>() { //生成一个匿名的Iterator对象
@Override
public boolean hasNext() { //这里随便写的，直接返回true，这将会导致无限循环
return true;
}
@Override
public String next() { //每次就直接返回一个字符串吧
return "测试";
}
};
}
}
可以看到，直接就支持这种语法了，虽然我们这个是自己写的，并不是集合类：
public static void main(String[] args) {
Test test = new Test();
for (String s : test) {
System.out.println(s);
}
}
是不是感觉集合类的设计非常巧妙？
我们这里再来介绍一下ListIterator，这个迭代器是针对于List的强化版本，增加了更多方便的操作，因为List是有序集合，所以它支持两种方向的遍历操作，不仅能从前向后，也可以从后向前：
public interface ListIterator<E> extends Iterator<E> {
//原本就有的
boolean hasNext();
//原本就有的
E next();
//查看前面是否有已经遍历的元素
boolean hasPrevious();
//跟next相反，这里是倒着往回遍历
E previous();
//返回下一个待遍历元素的下标
int nextIndex();
//返回上一个已遍历元素的下标
int previousIndex();
//原本就有的
void remove();
//将上一个已遍历元素修改为新的元素
void set(E e);
//在遍历过程中，插入新的元素到当前待遍历元素之前
void add(E e);
}
我们来测试一下吧：
public static void main(String[] args) {
List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));
ListIterator<String> iterator = list.listIterator();
iterator.next(); //此时得到A
iterator.set("X"); //将A原本位置的上的元素设定为成新的
System.out.println(list);
}
这种迭代器因为能够双向遍历，所以说可以反复使用。
Queue和Deque
通过前面的学习，我们已经了解了List的使用，其中LinkedList除了可以直接当做列表使用之外，还可以当做其他的数据结构使用，可以看到它不仅仅实现了List接口：
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
这个Deque接口是干嘛的呢？我们先来看看它的继承结构：
我们先来看看队列接口，它扩展了大量队列相关操作：
public interface Queue<E> extends Collection<E> {
//队列的添加操作，是在队尾进行插入（只不过List也是一样的，默认都是尾插）
//如果插入失败，会直接抛出异常
boolean add(E e);
//同样是添加操作，但是插入失败不会抛出异常
boolean offer(E e);
//移除队首元素，但是如果队列已经为空，那么会抛出异常
E remove();
//同样是移除队首元素，但是如果队列为空，会返回null
E poll();
//仅获取队首元素，不进行出队操作，但是如果队列已经为空，那么会抛出异常
E element();
//同样是仅获取队首元素，但是如果队列为空，会返回null
E peek();
}
我们可以直接将一个LinkedList当做一个队列来使用：
public static void main(String[] args) {
Queue<String> queue = new LinkedList<>(); //当做队列使用，还是很方便的
queue.offer("AAA");
queue.offer("BBB");
System.out.println(queue.poll());
System.out.println(queue.poll());
}
我们接着来看双端队列，实际上双端队列就是队列的升级版，我们一个普通的队列就是：
普通队列中从队尾入队，队首出队，而双端队列允许在队列的两端进行入队和出队操作：
利用这种特性，双端队列既可以当做普通队列使用，也可以当做栈来使用，我们来看看Java中是如何定义的Deque双端队列接口的：
//在双端队列中，所有的操作都有分别对应队首和队尾的
public interface Deque<E> extends Queue<E> {
//在队首进行插入操作
void addFirst(E e);
//在队尾进行插入操作
void addLast(E e);
//不用多说了吧？
boolean offerFirst(E e);
boolean offerLast(E e);
//在队首进行移除操作
E removeFirst();
//在队尾进行移除操作
E removeLast();
//不用多说了吧？
E pollFirst();
E pollLast();
//获取队首元素
E getFirst();
//获取队尾元素
E getLast();
//不用多说了吧？
E peekFirst();
E peekLast();
//从队列中删除第一个出现的指定元素
boolean removeFirstOccurrence(Object o);
//从队列中删除最后一个出现的指定元素
boolean removeLastOccurrence(Object o);
// *** 队列中继承下来的方法操作是一样的，这里就不列出了 ***
...
// *** 栈相关操作已经帮助我们定义好了 ***
//将元素推向栈顶
void push(E e);
//将元素从栈顶出栈
E pop();
// *** 集合类中继承的方法这里也不多种介绍了 ***
...
//生成反向迭代器，这个迭代器也是单向的，但是是next方法是从后往前进行遍历的
Iterator<E> descendingIterator();
}
我们可以来测试一下，比如我们可以直接当做栈来进行使用：
public static void main(String[] args) {
Deque<String> deque = new LinkedList<>();
deque.push("AAA");
deque.push("BBB");
System.out.println(deque.pop());
System.out.println(deque.pop());
}
可以看到，得到的顺序和插入顺序是完全相反的，其实只要各位理解了前面讲解的数据结构，就很简单了。我们来测试一下反向迭代器和正向迭代器：
public static void main(String[] args) {
Deque<String> deque = new LinkedList<>();
deque.addLast("AAA");
deque.addLast("BBB");
Iterator<String> descendingIterator = deque.descendingIterator();
System.out.println(descendingIterator.next());
Iterator<String> iterator = deque.iterator();
System.out.println(iterator.next());
}
该博客转载自B站UP青空的霞光
- 感谢你赐予我前进的力量
-
微信 
支付宝
赞赏者名单
因为你们的支持让我意识到写文章的价值🙏
本文是原创文章，采用 CC BY-NC-ND 4.0 协议，完整转载请注明来自 小峰同学
阅读建议
评论
匿名评论
隐私政策
你无需删除空行，直接评论以获取最佳展示效果