Java--LinkedList真的比ArrayList添加元素快？Open JDK JMH带你揭开真相_为什么arraylist添加元素比linklist快-CSDN博客

本文链接：https://blog.csdn.net/m0_57889860/article/details/137870819

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新网络安全全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上网络安全知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip204888 （备注网络安全）

正文

（2）ArrayList几个重要属性各自的含义？

ArrayList底层主要属性有elementData对象数组、size集合大小（数组中已存储的元素个数，非数组容量大小）、DEFAULT_CAPACITY默认容量为10（new实例化时数组初始化容量大小为0，执行add添加元素时才指定初始化容量为DEFAULT_CAPACITY）~

（3）ArrayList 属性elementData数组使用了transient修饰，作用是什么？

使用transient关键词修饰属性，表示不能被外部方法序列化
ArrayList 的elementData数组是动态扩容的，并非所有被分配的内存空间都存储了数据，如果采用外部序列化法实现序列化，那整个elementData都会被序列化
ArrayList为了避免这些没有存储数据的内存空间被序列化，内部提供了两个私有方法 writeObject 以及 readObject 来自我完成序列化与反序列化，从而在序列化与反序列化数组时节省了空间和时间。

（4）⭐ArrayList如何添加元素效率最高？

ArrayList 新增元素的方法常用的有两种，一种是直接添加元素，另外一种是添加元素到指定位置
使用ArrayList的add(E e)方法直接添加元素，默认将元素添加到数组尾部，在没有发生扩容的情况下，不会有数组的复制重排过程，效率最高
使用add(int index,E element)添加元素到指定位置，index等于0，表示在头部添加元素，会导致在该位置后的所有元素都需要进行复制排列，时间复杂度O(n)-线性复杂度，效率很低
因此ArrayList在初始化时指定合适的数组容量大小，直接添加元素到数组尾部，那么ArrayList 添加元素的效率反而比LinkedList高

（5）⭐ArrayList使用哪种方式遍历查找效率最高？

ArrayList使用for循环遍历查找效率最高，因为ArrayList底层数据结构为数组，数组是一块连续内存的空间，并且ArrayList实现了 RandomAccess 接口标志，意味着 ArrayList 拥有快速随机访问特性，对于元素的查找，时间复杂度为O(1)-常数复杂度，效率最高。

（6）⭐ArrayList在foreach循环或迭代器遍历中，调用自身的remove(E e)方法删除元素，会导致什么问题？

会抛ConcurrentModificationException异常，原因是集合修改次数modCount和迭代器期望修改次数expectedModCount不一致
foreach循环相当于迭代器，在迭代器遍历中，使用ArrayList自身的remove(E e)方法删除元素，内部会进行modCount++，但并不会进行迭代器的expectedModCount++，因此导致进入下一趟遍历调用迭代器的next()方法中，内部比对两者不一致抛出ConcurrentModificationException异常
目前开发规范都是禁止在迭代器中使用集合自身的remove/add方法，如果要在循环中删除元素，应该使用迭代器的remove删除，也可以使用for循环进行remove删除元素，不过需要角标减1（i--）

（7）⭐ArrayList初始化容量大小足够的情况下，相比于LinkedList在头部、中间、尾部添加的效率如何？

头部：
ArrayList 底层结构是数组，数组是一块连续的内存空间，添加元素到数组头部时，需要对头部以后的所有数据进行复制重排，效率最低，时间复杂度为O(n)
LinkedList 底层结构是链表，通过addFirst(E e)方法添加元素到头部时，效率也最高，时间复杂度为O(1)-常数复杂度，不过多了新节点创建和指针变换的过程
LinkedList也可以通过add(index, E element)方法，指定index等于0时，也表示添加元素到头部时，不过此过程会先通过二分法查找找到指定位置的节点元素，而头部刚好处于前半部分的第一个，找到该节点就返回，再进行后续新节点创建和指针变换，不过这种方式添加元素的综合时间复杂度为O(logN)-对数复杂度

中间：
ArrayList 添加元素到数组中间，往后的所有数据需要都进行复制重排，时间复杂度为O(n)；
LinkedList添加元素到中间，二分法查找发挥的作用最低，不论从前往后，还是从后往前，链表被循环遍历的次数都是最多的，效率最低，综合时间复杂度为O(n)

结尾：
ArrayList 添加元素尾部，不需要进行复制重排数组数据，效率最高，时间复杂度为O(1)
LinkedList添加元素到尾部，不需要查找元素，效率也是最高的，但是多了新节点对象创建以及变换指针指向对象的过程，效率比ArrayList低一些，时间复杂度为O(1)

（8）⭐ArrayList为什么是非线程安全的？

因为ArrayList添加元素时，主要会进行这两步操作，一是判断数组容量是否满足大小，二是在数组对应位置赋值，这2步操作在多线程访问时都存在安全隐患~
第1个隐患是，判断数组容量是否满足大小的ensureCapacityInternal(size+1)方法中，可能多个线程会读取到相同的size值，如果第1个线程传入size+1进行判断容量时，刚好满足容量大小，就不会进行扩容，同理，其他线程也不会进行扩容，这样就会导致进行下一步其他线程在数组对应位置赋值时，抛出数组下标越界ArrayIndexOutOfBoundsException异常
第2个隐患是，在数组对应位置赋值elementData [size++] = e; 实际上会被分解成两步进行，先赋值 elementData [size] = e;再进行size=size+1; 可能第1个线程刚赋值完，还没进行size+1，其他线程又对同一位置进行赋值，导致前面线程添加的元素值被覆盖。

1.2 LinkedList

1.2.1 LinkedList特性

⭐继承AbstractSequentialList抽象类，实现了List接口，还实现了Deque双向队列以及克隆Cloneable和序列化java.io.Serializable
⭐底层数据结构是双向链表，在头部和尾部添加、删除元素效率比较高，非线程安全
⭐JDK1.7后Entry<E> header属性被替换为Node<E> first和Node<E> last首尾节点属性
替换3点优势：
first/last 属性能更清晰地表达链表的链头和链尾概念
first/last 方式可以在初始化 LinkedList 的时候节省 new 一个 Entry
first/last 方式最重要的性能优化是链头和链尾的插入删除操作更加快捷了。

1.2.2 LinkedList常用API

⭐增：效率add(E e) = addLast(E e) = addFirst(E e) > add(int index,E element)
⭐删：效率removeFirst() = removeLast() > remove(int index) >remove(Object o)
⭐改：set(int index,E element)
⭐查：get(int index)

1.2.3 LinkedList常见面试题（附参考答案）

（1）LinkedList为什么不能实现RandomAccess接口？

因为LinkedList底层数据结构是链表，内存地址不连续，只能通过指针来定位，不支持随机快速访问，所以不能实现 RandomAccess 接口

（2）LinkedList几个重要属性各自的含义？

LinkedList底层主要属性有size集合大小（链表长度）、first链表头部节点、last链表尾部节点，并且也都使用transient修饰，表示不能外部序列化与反序列化，内部自己实现了序列化与反序列化。

（3）LinkedList默认添加元素是怎么实现的？

LinkedList添加元素的方法主要有直接添加和指定位置添加
直接添加元素有add(E e)方法和addAll(Collection c)方法，指定位置添加元素有addFirst(E e)、addLast(E e)、add(int index,E element)、addAll(int index,Collection c)方法
直接添加元素默认添加到链表的尾部，不需要先查找节点，直接通过尾部节点，创建新节点和变换指针指向新节点
指定位置添加元素，如果是添加元素到链表头部或尾部，都不需要先查找节点，直接通过头部或尾部节点，创建新节点和变换指针指向新节点，但是如果是add(int index,E element)添加元素到非首尾位置，会先使用二分查找到该位置对应的节点，再通过该节点，创建新节点和变换指针指向新节点

（4）LinkedList使用哪种方式遍历效率最高？

LinkedList底层数据结构是双向链表的，使用foreach循环或iterator迭代器遍历效率最高，通过迭代器的hasNext()、next()快速遍历元素
需要注意的是尽量避免使用for循环遍历LinkedList，因为每一次循环，都会使用二分查找先找到指定位置的节点，再通过该节点新建节点以及变换指针，效率极其低下。

（5）LinkedList使用Iterator迭代器遍历时，进行remove(E e)操作，迭代器的指针会发生什么变化？

LinkedList使用迭代器遍历，内部自己实现的是ListIterator接口，主要有lastReturned最后返回节点、next下一节点、nextIndex下一指针以及expectedModCount期望修改次数4个重要属性，其中nextIndex下一指针从0开始
LinkedList迭代器遍历时，每进行一趟遍历，都会经过hasNext()、next()操作，并且在next()方法中，进行了nextIndex++操作
当进行到某一趟遍历，调用remove()进行操作元素，会通过lastReturned进行解链，并且将next = lastReturned和nextIndex--操作，也就是迭代器的下一指针会减一

（6）LinkedList默认位置添加元素和指定位置添加元素分别怎么实现，哪种性能更高？

LinkedList默认位置添加元素通过add(E e)方法实现，默认位置是添加元素到尾部，时间复杂度是O(1)-常数复杂度，效率最高。
LinkedList指定位置添加元素通过addLast(E e)、addFirst(E e)方法添加元素到尾部和头部，add(E e)方法默认位置是添加元素到尾部，时间复杂度是O(1)-常数复杂度，效率最高。
LinkedList还有一种指定位置添加元素通过add(int index, E element)方法实现，这种方式添加元素前，需要先通过二分查找找到指定位置的元素，再通过该元素进行新节点创建以及指针变换，综合时间复杂度是O(logN)，如果添加元素的位置刚好在中间，二分查找发挥的作用最小，效率比较低~

（7）List集合迭代器遍历使用Iterator和ListIterator有什么不同？

都是迭代器，都可以用来遍历对应的实现类
Iterator允许遍历所有实现Iterator接口的实现类，而ListIterator只能遍历List集合
两者都有hasNext()、next()、remove()方法正向操作列表，ListIterator还可以进行逆向操作列表和往集合中添加元素

二、JMH测试ArrayList和LinkedList性能

2.1 JMH是什么？

官方介绍
在这里插入图片描述
简单介绍

JMH全称Java Microbenchmark Harness（Java微基准套件），是Oracle 官方Open JDK提供的一款Java微基准性能测试工具，主要是基于方法层面的基准测试，纳秒级精确度~

2.2 JMH应用场景？

【典型应用】

精确验证某个方法执行时间
测试接口不同实现的吞吐量
等等…

日常开发及优化Java代码时，当定位到热点方法，想进一步优化热点方法的性能时，可以通过JHM精确验证某个方法执行时间，根据测试结果不断进行优化~

2.3 JMH测试ArrayList和LinkedList（揭开真相）

应用场景不在于有多少，在于你用不用得到，这里我们就利用JMH精确验证某个方法执行时间，来验证本文的主题LinkedList添加元素真的比ArrayList快？

大致思路：

分别实现LinkedList和ArrayList默认添加元素即尾部添加元素的方法~
利用JMH分别对两个方法进行基准测试，根据测试结果进行分析性能~

2.3.1 代码实现

（1）添加依赖
需要依赖jmh-core和jmh-generator-annprocess两个架包，可以去Maven官网下载~

Maven工程直接在pom.xml中添加依赖如下：

		<dependency>
			<groupId>org.openjdk.jmh</groupId>
			<artifactId>jmh-core</artifactId>
			<version>1.26</version>
			<scope>provided</scope>
		</dependency>

		<dependency>
			<groupId>org.openjdk.jmh</groupId>
			<artifactId>jmh-generator-annprocess</artifactId>
			<version>1.26</version>
			<scope>provided</scope>
		</dependency>

（2）添加元素方法

package com.justin.java;

import org.openjdk.jmh.annotations.\*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.TimeUnit;

@BenchmarkMode(Mode.Throughput) //基准测试类型：吞吐量(单位时间内调用了多少次)
@OutputTimeUnit(TimeUnit.MILLISECONDS) //基准测试结果的时间类型：毫秒
@Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS) //预热：2 轮,每次1秒
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS) //度量：测试5轮,每轮1秒
@Fork(1) //Fork出1个线程来测试
@State(Scope.Thread) // 每个测试线程分配1个实例
public class ArrayAndLinkedJmhTest {
    private List<Object> arrayList;
    private List<Object> linkedList;
    @Param({"10", "100", "1000"})
    private int count; //分别测试不同个数的添加元素

    @Setup(Level.Trial)
    public void init() {
        arrayList = new ArrayList<>();
        linkedList = new LinkedList<>();
    }

    public static void main(String[] args) throws RunnerException {
        //启动基准测试
        Options opt = new OptionsBuilder()
                .include(ArrayAndLinkedJmhTest.class.getSimpleName()) //要导入的测试类
                .output("C:\\Users\\Administrator\\Desktop\\ArrayAndLinkedJmhTest.log") //输出测试结果的文件
                .build();
        //执行测试
        new Runner(opt).run();
    }

    @Benchmark
    public void arrayListAddTest() {
        for (int i = 0; i < count; i++) {
            arrayList.add("Justin");
        }
    }

    @Benchmark
    public void linkedListAddTest() {
        for (int i = 0; i < count; i++) {
            linkedList.add("Justin");
        }
    }

}

注解说明

注解	说明
`@BenchmarkMode(Mode.AverageTime)`	基准测试类型: `AverageTime`表示平均时间
`@OutputTimeUnit(TimeUnit.NANOSECONDS)`	基准测试结果的时间类型：`NANOSECONDS`表示微秒
`@Warmup(iterations = 5)`	预热：`iterations`指定预热迭代几轮
`@Measurement(iterations = 10)`	度量：`iterations` 指定迭代几轮
`@Fork(2)`	`Fork`出`2`个线程来测试
`@State(Scope.Thread)`	每个测试线程分配`1`个实例
`@Param({"10", "100", "1000"})`	指定某项参数的多种情况，数值根据实际给定
`@Setup(Level.Trial)`	初始化方法，在全部`Benchmark`运行之前进行
`@BenchmarkMode`	用在方法上，表示该方法要进行基准测试，类似`JUnit`的`@Test`
`@TearDown(Level.Trial)`	结束方法，在全部`Benchmark`运行之后进行

更多官方Sample：
OpenJDK Samples
GitHub OpenJDK Samples

**由于添加元素消耗的内存比较大，idea执行基准测试过程中可能会出现内存泄露的报错：**java.lang.OutOfMemoryError: Java heap space
加大JVM的内存参数值即可，例如idea中调整方式：
Help -> Edit Custom VM Options…
在这里插入图片描述

2.3.2 结果分析

分析输出的结果文件ArrayAndLinkedJmhTest.log，输出的内容很多，只要前面没有error都不用管，直接拉到最后看Score结果~

Benchmark                                (count)  Mode  Cnt     Score     Error  Units
ArrayAndLinkedJmhTest.arrayListAddTest        10  avgt   20    74.287 ±   1.629  ns/op
ArrayAndLinkedJmhTest.arrayListAddTest       100  avgt   20   371.329 ±  23.952  ns/op
ArrayAndLinkedJmhTest.arrayListAddTest      1000  avgt   20  3118.537 ±  38.943  ns/op
ArrayAndLinkedJmhTest.linkedListAddTest       10  avgt   20    95.773 ±   1.261  ns/op
ArrayAndLinkedJmhTest.linkedListAddTest      100  avgt   20   907.471 ±  13.856  ns/op
ArrayAndLinkedJmhTest.linkedListAddTest     1000  avgt   20  8901.777 ± 108.044  ns/op

示例中我们使用注解的是@BenchmarkMode(Mode.AverageTime)和OutputTimeUnit(TimeUnit.NANOSECONDS)，因此测试的结果是ns/ops（每次调用需要多少微秒），每次调用添加相同的元素，平均时间越高，表明效率越低~

对应的结果指标是Score，可以看到ArrayList添加元素从少到多，效率都吊打LinkedList~

不过，细心的同学可能发现了，ArrayList之所以吊打LinkedList这么猛，是因为代码中ArrayList指定了合适的初始化容量大小

List<Object> arrayList = new ArrayList<>(count);

加上添加元素默认是在尾部进行，可谓是如虎添翼，ArrayList底层数据结构是数组，数组是一块连续的内存空间，从数组尾部添加数据时，不需要进行任何数组数据的复制重排，效率最高，时间复杂度为O(1)

ArrayList默认添加元素的关键源码

	//关键源码1
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    ...
    //关键源码2
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }    
    ...
    //关键源码3
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }    
	...
	//关键源码4
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

虽然LinkedList添加元素到尾部，也不需要查找元素，效率也是最高的，但是多了新节点对象创建以及变换指针指向对象的过程，时间复杂度为O(1)~

LinkedList默认添加元素源码

    public boolean add(E e) {
        linkLast(e);


### 如何自学黑客&网络安全


#### 黑客零基础入门学习路线&规划


**初级黑客**  
 **1、网络安全理论知识（2天）**  
 ①了解行业相关背景，前景，确定发展方向。  
 ②学习网络安全相关法律法规。  
 ③网络安全运营的概念。  
 ④等保简介、等保规定、流程和规范。（非常重要）


**2、渗透测试基础（一周）**  
 ①渗透测试的流程、分类、标准  
 ②信息收集技术：主动/被动信息搜集、Nmap工具、Google Hacking  
 ③漏洞扫描、漏洞利用、原理，利用方法、工具（MSF）、绕过IDS和反病毒侦察  
 ④主机攻防演练：MS17-010、MS08-067、MS10-046、MS12-20等


**3、操作系统基础（一周）**  
 ①Windows系统常见功能和命令  
 ②Kali Linux系统常见功能和命令  
 ③操作系统安全（系统入侵排查/系统加固基础）


**4、计算机网络基础（一周）**  
 ①计算机网络基础、协议和架构  
 ②网络通信原理、OSI模型、数据转发流程  
 ③常见协议解析（HTTP、TCP/IP、ARP等）  
 ④网络攻击技术与网络安全防御技术  
 ⑤Web漏洞原理与防御：主动/被动攻击、DDOS攻击、CVE漏洞复现


**5、数据库基础操作（2天）**  
 ①数据库基础  
 ②SQL语言基础  
 ③数据库安全加固


**6、Web渗透（1周）**  
 ①HTML、CSS和JavaScript简介  
 ②OWASP Top10  
 ③Web漏洞扫描工具  
 ④Web渗透工具：Nmap、BurpSuite、SQLMap、其他（菜刀、漏扫等）  
 恭喜你，如果学到这里，你基本可以从事一份网络安全相关的工作，比如渗透测试、Web 渗透、安全服务、安全分析等岗位；如果等保模块学的好，还可以从事等保工程师。薪资区间6k-15k


到此为止，大概1个月的时间。你已经成为了一名“脚本小子”。那么你还想往下探索吗？


如果你想要入坑黑客&网络安全，笔者给大家准备了一份：282G全网最全的网络安全资料包评论区留言即可领取！


**7、脚本编程（初级/中级/高级）**  
 在网络安全领域。是否具备编程能力是“脚本小子”和真正黑客的本质区别。在实际的渗透测试过程中，面对复杂多变的网络环境，当常用工具不能满足实际需求的时候，往往需要对现有工具进行扩展，或者编写符合我们要求的工具、自动化脚本，这个时候就需要具备一定的编程能力。在分秒必争的CTF竞赛中，想要高效地使用自制的脚本工具来实现各种目的，更是需要拥有编程能力.


如果你零基础入门，笔者建议选择脚本语言Python/PHP/Go/Java中的一种，对常用库进行编程学习；搭建开发环境和选择IDE,PHP环境推荐Wamp和XAMPP， IDE强烈推荐Sublime；·Python编程学习，学习内容包含：语法、正则、文件、 网络、多线程等常用库，推荐《Python核心编程》，不要看完；·用Python编写漏洞的exp,然后写一个简单的网络爬虫；·PHP基本语法学习并书写一个简单的博客系统；熟悉MVC架构，并试着学习一个PHP框架或者Python框架 (可选)；·了解Bootstrap的布局或者CSS。

**8、超级黑客**  
 这部分内容对零基础的同学来说还比较遥远，就不展开细说了，附上学习路线。  
 ![img](https://img-blog.csdnimg.cn/img_convert/3fd39c2ba8ec22649979f245f4221608.webp?x-oss-process=image/format,png)


#### 网络安全工程师企业级学习路线


![img](https://img-blog.csdnimg.cn/img_convert/931ac5ac21a22d230645ccf767358997.webp?x-oss-process=image/format,png)  
 如图片过大被平台压缩导致看不清的话，评论区点赞和评论区留言获取吧。我都会回复的


视频配套资料&国内外网安书籍、文档&工具


当然除了有配套的视频，同时也为大家整理了各种文档和书籍资料&工具，并且已经帮大家分好类了。

![img](https://img-blog.csdnimg.cn/img_convert/153b2778a3fe5198265bed9635d63469.webp?x-oss-process=image/format,png)  
 一些笔者自己买的、其他平台白嫖不到的视频教程。  
 ![img](https://img-blog.csdnimg.cn/img_convert/32eb4b22aa740233c5198d3c161b37e8.webp?x-oss-process=image/format,png)





**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注网络安全）**
![img](https://img-blog.csdnimg.cn/img_convert/8f0a2cbdbdf2a0f330cbec25c0866fbf.png)

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

套资料&国内外网安书籍、文档&工具


当然除了有配套的视频，同时也为大家整理了各种文档和书籍资料&工具，并且已经帮大家分好类了。

![img](https://img-blog.csdnimg.cn/img_convert/153b2778a3fe5198265bed9635d63469.webp?x-oss-process=image/format,png)  
 一些笔者自己买的、其他平台白嫖不到的视频教程。  
 ![img](https://img-blog.csdnimg.cn/img_convert/32eb4b22aa740233c5198d3c161b37e8.webp?x-oss-process=image/format,png)





**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注网络安全）**
[外链图片转存中...(img-4j3WaVLB-1713333622172)]

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**