java集合框架

字数统计: 5.1k字   |   阅读时长≈ 22分

集合框架

0x00 集合接口

接口 接口描述
Collection接口 Collection 是最基本的集合接口，一个 Collection 代表一组 Object，即 Collection 的元素，Java不提供直接继承自 Collection 的类，只提供继承于的子接口（如 List 和 Set）。
Collection 接口存储一组不唯一，无序的对象。
List接口 List 接口是一个有序的 Collection，使用此接口能够精确的控制每个元素插入的位置，能够通过索引（元素在 List 中位置，类似于数组的下标）来访问 List 中的元素，第一个元素的索引为 0，而且运行有相同的元素。
List 接口存储一组不唯一，有序（插入顺序）的对象。
Set Set 具有与 Collection 完全一样的接口，只是行为上不同，Set 不保存重复的元素。
Set 接口存储一组唯一，无序的对象。
SortedSet 继承于 Set 保存有序的集合。
Map Map 接口存储一组键值对象，提供key（键）到 value（值）的映射。
Map.Entry 描述在一个 Map 中的一个元素（键/值对）。是一个 Map 的内部接口。
SortedMap 继承于 Map，使 Key 保持在升序排列。
Enumeration 这是一个传统的接口和定义的方法，通过它可以枚举（一次获得一个）对象集合中的元素。这个传统接口已被迭代器取代。

Set 和 List 的区别

  • Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。
  • Set 检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变**<实现类有 HashSet，TreeSet>**
  • List 和数组类似，可以动态增长，根据实际存储的数据的长度自动增长 List 的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变**<实现类有 ArrayList，LinkedList，Vector>**

0x01 集合实现类

Java 提供了一套实现了 Collection 接口的标准集合类。其中一些是具体类，这些类可以直接拿来使用，而另外一些是抽象类，提供了接口的部分实现。
标准集合类：

类名 类描述
AbstractCollection 实现了大部分的集合接口。
AbstractList 继承于 AbstractCollection 并且实现了大部分 List 接口。
AbstractSequentialList 继承于 AbstractList，提供了对数据元素的访问而不是随机访问。
LinkedList 该类实现了 List 接口，允许有 null（空）元素。主要用于创建链表数据结构，该类没有同步方法，如果多个线程同时访问一个 List，则必须自己实现访问同步，解决方法就是在创建 List 时候构造一个同步的 List。例如：
List list=Collections.synchronizedList(new LinkedList(...));
LinkedList 查找效率低。
ArrayList 该类也是实现了List的接口，实现了可变大小的数组，随机访问和遍历元素时，提供更好的性能。该类也是非同步的,在多线程的情况下不要使用。ArrayList 增长当前长度的50%，插入删除效率低。
AbstractSet 继承于AbstractCollection 并且实现了大部分Set接口。
HashSet 该类实现了Set接口，不允许出现重复元素，不保证集合中元素的顺序，允许包含值为null的元素，但最多只能一个。
LinkedHashSet 具有可预知迭代顺序的 Set 接口的哈希表和连接列表实现。
AbstractMap 实现了大部分的Map接口。
HashMap HashMap 是一个散列表，它存储的内容是键值对（key-value）映射。
该类实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条的键为 null，不支持线程同步。
TreeMap 继承了AbstractMap，并且使用一颗树。
WeakHashMap 继承AbstractMap类，使用弱密钥的哈希表。
LinkedHashMap 继承于HashMap，使用元素的自然顺序对元素进行排序。
IdentityHashMap 继承AbstractMap类，比较文档时使用引用相等。

java.util包：

类名 类描述
Vector 该类和 ArrayList 非常相似，但是该类是同步的，可以在多线程的情况使用，该类允许设置默认的增长长度，默认扩容方式为原来的 2 倍。
Stack 栈是 Vector 的一个子类，它实现了一个标准的后进先出的栈。
Dictionary Dictionary 类是一个抽象类，用来存储键/值对，作用和 Map 类相似。
Hashtable Hashtable 是 Dictionary（字典）类的子类，位于 java.util 包中。
Properties Properties 继承于 Hashtable，表示一个持久的属性集，属性列表中每个键及其对应值都是一个字符串。
BitSet 一个 BitSet 类创建一种特殊类型的数组来保存位值。BitSet 中数组大小随需要增加。

0x02 ArrayList

img

ArrayList 类位于 java.util 包中，使用前需要引入它

1
2
3
import java.util.ArrayList; // 引入 ArrayList 类

ArrayList<E> objectName =new ArrayList<>();　 // 初始化
  • E：泛型数据类型，用于设置 objectName 的数据类型，只能为引用数据类型。
  • objectName：对象名。

ArrayList 是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。

添加元素

add() 方法

1
2
3
4
5
6
7
8
9
10
11
12
import java.util.ArrayList;

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        System.out.println(sites); //[Google, Runoob, Taobao, Weibo]
    }
}

访问元素

get() 方法

1
2
3
4
5
6
7
8
9
10
11
12
import java.util.ArrayList;

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        System.out.println(sites.get(1));  // 访问第二个元素  Runoob
    }
}

修改元素

set() 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
import java.util.ArrayList;

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        sites.set(2, "Wiki"); // 第一个参数为索引位置，第二个为要修改的值
        System.out.println(sites); // [Google, Runoob, Wiki, Weibo]
    }
}

删除元素

remove() 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
import java.util.ArrayList;

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        sites.remove(3); // 删除第四个元素
        System.out.println(sites); // [Google, Runoob, Taobao]
    }
}

计算大小

size() 方法

1
2
3
4
5
6
7
8
9
10
11
12
import java.util.ArrayList;

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        System.out.println(sites.size()); // 4
    }
}

迭代数组列表

我们可以使用 for 来迭代数组中的元素：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import java.util.ArrayList;

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        for (int i = 0; i < sites.size(); i++) {
            System.out.print(sites.get(i)+" ");  // Google Runoob Taobao Weibo
        }
    }
}

也可以使用 for-each 来迭代元素：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import java.util.ArrayList;

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        for (String i : sites) {
            System.out.print(i+" "); // Google Runoob Taobao Weibo
        }
    }
}

其他的引用类型

只能为引用数据类型，这时我们就需要使用到基本类型的包装类。

基本类型 引用类型
boolean Boolean
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character

BigInteger、BigDecimal 用于高精度的运算，BigInteger 支持任意精度的整数，也是引用类型，但它们没有相对应的基本类型。

ArrayList 排序

Collections 类也是一个非常有用的类，位于 java.util 包中，提供的 sort() 方法可以对字符或数字列表进行排序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import java.util.ArrayList;
import java.util.Collections;  // 引入 Collections 类

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Taobao");
        sites.add("Wiki");
        sites.add("Runoob");
        sites.add("Weibo");
        sites.add("Google");
        Collections.sort(sites);  // 字母排序
        for (String i : sites) {
            System.out.print(i + " "); // Google Runoob Taobao Weibo Wiki
        }
    }
}

Java ArrayList 常用方法

方法 描述
add() 将元素插入到指定位置的 arraylist 中
addAll() 添加集合中的所有元素到 arraylist 中
clear() 删除 arraylist 中的所有元素
clone() 复制一份 arraylist
contains() 判断元素是否在 arraylist
get() 通过索引值获取 arraylist 中的元素
indexOf() 返回 arraylist 中元素的索引值
removeAll() 删除存在于指定集合中的 arraylist 里的所有元素
remove() 删除 arraylist 里的单个元素
size() 返回 arraylist 里元素数量
isEmpty() 判断 arraylist 是否为空
subList() 截取部分 arraylist 的元素
set() 替换 arraylist 中指定索引的元素
sort() 对 arraylist 元素进行排序
toArray() 将 arraylist 转换为数组
toString() 将 arraylist 转换为字符串
ensureCapacity() 设置指定容量大小的 arraylist
lastIndexOf() 返回指定元素在 arraylist 中最后一次出现的位置
retainAll() 保留 arraylist 中在指定集合中也存在的那些元素
containsAll() 查看 arraylist 是否包含指定集合中的所有元素
trimToSize() 将 arraylist 中的容量调整为数组中的元素个数
removeRange() 删除 arraylist 中指定索引之间存在的元素
replaceAll() 将给定的操作内容替换掉数组中每一个元素
removeIf() 删除所有满足特定条件的 arraylist 元素
forEach() 遍历 arraylist 中每一个元素并执行特定操作

0x03 LinkedList

链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。

LinkedList 继承了 AbstractSequentialList 类。

LinkedList 实现了 Queue 接口，可作为队列使用。

LinkedList 实现了 List 接口，可进行列表的相关操作。

LinkedList 实现了 Deque 接口，可作为队列使用。

LinkedList 实现了 Cloneable 接口，可实现克隆。

LinkedList 实现了 java.io.Serializable 接口，即可支持序列化，能通过序列化去传输。

img

LinkedList 类位于 java.util 包中，使用前需要引入它

1
2
3
4
5
6
// 引入 LinkedList 类
import java.util.LinkedList; 

LinkedList<E> list = new LinkedList<E>();   // 普通创建方法
或者
LinkedList<E> list = new LinkedList(Collection<? extends E> c); // 使用集合创建链表

不同情况下使用 ArrayList 和 LinkedList：

以下情况使用 ArrayList :

  • 频繁访问列表中的某一个元素。
  • 只需要在列表末尾进行添加和删除元素操作。

以下情况使用 LinkedList：

  • 需要通过循环迭代来访问列表中的某些元素。
  • 需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。

创建一个简单的链表实例：

1
2
3
4
5
6
7
8
9
10
11
12
import java.util.LinkedList;

public class RunoobTest {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        System.out.println(sites); // [Google, Runoob, Taobao, Weibo]
    }
}

在列表开头添加元素：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 引入 LinkedList 类
import java.util.LinkedList;

public class RunoobTest {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        // 使用 addFirst() 在头部添加元素
        sites.addFirst("Wiki");
        System.out.println(sites); // [Wiki, Google, Runoob, Taobao]
    }
}

在列表结尾添加元素：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 引入 LinkedList 类
import java.util.LinkedList;

public class RunoobTest {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        // 使用 addLast() 在尾部添加元素
        sites.addLast("Wiki");
        System.out.println(sites); // [Google, Runoob, Taobao, Wiki]
    }
}

在列表开头移除元素：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 引入 LinkedList 类
import java.util.LinkedList;

public class RunoobTest {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        // 使用 removeFirst() 移除头部元素
        sites.removeFirst();
        System.out.println(sites); //  [Runoob, Taobao, Weibo] 
    }
}

在列表结尾移除元素：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 引入 LinkedList 类
import java.util.LinkedList;

public class RunoobTest {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        // 使用 removeLast() 移除尾部元素
        sites.removeLast();
        System.out.println(sites); //  [Google, Runoob, Taobao] 
    }
}

获取列表开头的元素：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 引入 LinkedList 类
import java.util.LinkedList;

public class RunoobTest {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        // 使用 getFirst() 获取头部元素
        System.out.println(sites.getFirst()); // Google
    }
}

获取列表结尾的元素：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 引入 LinkedList 类
import java.util.LinkedList;

public class RunoobTest {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        // 使用 getLast() 获取尾部元素
        System.out.println(sites.getLast()); // Weibo
    }
}

迭代元素

我们可以使用 for 配合 size() 方法来迭代列表中的元素：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 引入 LinkedList 类
import java.util.LinkedList;

public class RunoobTest {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        for (int size = sites.size(), i = 0; i < size; i++) {
            System.out.print(sites.get(i) + " "); // Google Runoob Taobao Weibo
        }
    }
}

也可以使用 for-each 来迭代元素：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 引入 LinkedList 类
import java.util.LinkedList;

public class RunoobTest {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        for (String i : sites) {
            System.out.print(i + " "); // Google Runoob Taobao Weibo
        }
    }
}

常用方法

方法 描述
public boolean add(E e) 链表末尾添加元素，返回是否成功，成功为 true，失败为 false。
public void add(int index, E element) 向指定位置插入元素。
public boolean addAll(Collection c) 将一个集合的所有元素添加到链表后面，返回是否成功，成功为 true，失败为 false。
public boolean addAll(int index, Collection c) 将一个集合的所有元素添加到链表的指定位置后面，返回是否成功，成功为 true，失败为 false。
public void addFirst(E e) 元素添加到头部。
public void addLast(E e) 元素添加到尾部。
public boolean offer(E e) 向链表末尾添加元素，返回是否成功，成功为 true，失败为 false。
public boolean offerFirst(E e) 头部插入元素，返回是否成功，成功为 true，失败为 false。
public boolean offerLast(E e) 尾部插入元素，返回是否成功，成功为 true，失败为 false。
public void clear() 清空链表。
public E removeFirst() 删除并返回第一个元素。
public E removeLast() 删除并返回最后一个元素。
public boolean remove(Object o) 删除某一元素，返回是否成功，成功为 true，失败为 false。
public E remove(int index) 删除指定位置的元素。
public E poll() 删除并返回第一个元素。
public E remove() 删除并返回第一个元素。
public boolean contains(Object o) 判断是否含有某一元素。
public E get(int index) 返回指定位置的元素。
public E getFirst() 返回第一个元素。
public E getLast() 返回最后一个元素。
public int indexOf(Object o) 查找指定元素从前往后第一次出现的索引。
public int lastIndexOf(Object o) 查找指定元素最后一次出现的索引。
public E peek() 返回第一个元素。
public E element() 返回第一个元素。
public E peekFirst() 返回头部元素。
public E peekLast() 返回尾部元素。
public E set(int index, E element) 设置指定位置的元素。
public Object clone() 克隆该列表。
public Iterator descendingIterator() 返回倒序迭代器。
public int size() 返回链表元素个数。
public ListIterator listIterator(int index) 返回从指定位置开始到末尾的迭代器。
public Object[] toArray() 返回一个由链表元素组成的数组。
public T[] toArray(T[] a) 返回一个由链表元素转换类型而成的数组。

0x04 HashSet

HashSet 基于 HashMap 来实现的，是一个不允许有重复元素的集合。

HashSet 允许有 null 值。

HashSet 是无序的，即不会记录插入的顺序。

HashSet 不是线程安全的，如果多个线程尝试同时修改 HashSet，则最终结果是不确定的。必须在多线程访问时显式同步对 HashSet 的并发访问。

HashSet 实现了 Set 接口。

img

HashSet 类位于 java.util 包中，使用前需要引入它

1
import java.util.HashSet // 引入 HashSet 类

常用方法

变量和类型 方法 描述
boolean add(E e) 如果指定的元素尚不存在，则将其添加到此集合中。
void clear() 从该集中删除所有元素。
Object clone() 返回此 HashSet实例的浅表副本：未克隆元素本身。
boolean contains(Object o) 如果此set包含指定的元素，则返回 true 。
boolean isEmpty() 如果此集合不包含任何元素，则返回 true 。
Iterator<E> iterator() 返回此set中元素的迭代器。
boolean remove(Object o) 如果存在，则从该集合中移除指定的元素。
int size() 返回此集合中的元素数（基数）。
Spliterator<E> spliterator() 在此集合中的元素上创建*late-binding和失败快速 Spliterator 。

0x05 HashMap

HashMap 是一个散列表，它存储的内容是键值对（key-valuie）映射。

HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。

HashMap 是无序的，即不会记录插入的顺序。

HashMap 继承于AbstractMap，实现了 Map、Cloneable、java.io.Serializable 接口。

img

常用方法

方法 描述
clear() 删除 hashMap 中的所有键/值对
clone() 复制一份 hashMap
isEmpty() 判断 hashMap 是否为空
size() 计算 hashMap 中键/值对的数量
put() 将键/值对添加到 hashMap 中
putAll() 将所有键/值对添加到 hashMap 中
putIfAbsent() 如果 hashMap 中不存在指定的键，则将指定的键/值对插入到 hashMap 中。
remove() 删除 hashMap 中指定键 key 的映射关系
containsKey() 检查 hashMap 中是否存在指定的 key 对应的映射关系。
containsValue() 检查 hashMap 中是否存在指定的 value 对应的映射关系。
replace() 替换 hashMap 中是指定的 key 对应的 value。
replaceAll() 将 hashMap 中的所有映射关系替换成给定的函数所执行的结果。
get() 获取指定 key 对应对 value
getOrDefault() 获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值
forEach() 对 hashMap 中的每个映射执行指定的操作。
entrySet() 返回 hashMap 中所有映射项的集合集合视图。
keySet() 返回 hashMap 中所有 key 组成的集合视图。
values() 返回 hashMap 中存在的所有 value 值。
merge() 添加键值对到 hashMap 中
compute() 对 hashMap 中指定 key 的值进行重新计算
computeIfAbsent() 对 hashMap 中指定 key 的值进行重新计算，如果不存在这个 key，则添加到 hasMap 中
computeIfPresent() 对 hashMap 中指定 key 的值进行重新计算，前提是该 key 存在于 hashMap 中。

0x06 Iterator

Java Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法，可用于迭代 ArrayList 和 HashSet 等集合。

Iterator 是 Java 迭代器最简单的实现，ListIterator 是 Collection API 中的接口， 它扩展了 Iterator 接口。

img

迭代器 it 的两个基本操作是 next、hasNext 和 remove。

调用 it.next() 会返回迭代器的下一个元素，并且更新迭代器的状态。

调用 it.hasNext() 用于检测集合中是否还有元素。

调用 it.remove() 将迭代器返回的元素删除。

Iterator 类位于 java.util 包中，使用前需要引入它

1
import java.util.Iterator; // 引入 Iterator 类

获取一个迭代器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 引入 ArrayList 和 Iterator 类
import java.util.ArrayList;
import java.util.Iterator;

public class RunoobTest {
    public static void main(String[] args) {

        // 创建集合
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");

        // 获取迭代器
        Iterator<String> it = sites.iterator();

        // 输出集合中的第一个元素
        System.out.println(it.next()); // Google
    }
}

循环集合元素

1
2
3
while(it.hasNext()) {
    System.out.println(it.next());
}

删除元素

要删除集合中的元素可以使用 remove() 方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 引入 ArrayList 和 Iterator 类
import java.util.ArrayList;
import java.util.Iterator;

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<Integer>();
        numbers.add(12);
        numbers.add(8);
        numbers.add(2);
        numbers.add(23);
        Iterator<Integer> it = numbers.iterator();
        while(it.hasNext()) {
            Integer i = it.next();
            if(i < 10) {  
                it.remove();  // 删除小于 10 的元素
            }
        }
        System.out.println(numbers); // [12, 23]
    }
}
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发、网络安全、
服务器配置、JAVA安全的学习、Linux

联系QQ:1170516014

一个19级计科专业的小菜鸡