Day467&468&469，java面试高频考点

break;

}

//将 buffer 中的数据写入到 fileChannel02 – 2.txt

byteBuffer.flip();

fileChannel02.write(byteBuffer);

}

//关闭相关的流

fileInputStream.close();

fileOutputStream.close();

}

}

---

6、应用实例 4-拷贝文件 transferFrom 方法

• 实例要求

1. 使用 FileChannel(通道) 和 方法 transferFrom ，完成文件的拷贝

2. 拷贝一张图片

• 代码演示

public class NIOFileChannel04 {

public static void main(String[] args) throws Exception {

//创建相关流

FileInputStream fileInputStream = new FileInputStream(“d:\a.jpg”);

FileOutputStream fileOutputStream = new FileOutputStream(“d:\a2.jpg”);

//获取各个流对应的 filechannel

FileChannel sourceCh = fileInputStream.getChannel();

FileChannel destCh = fileOutputStream.getChannel();

//使用 transferForm 完成拷贝

destCh.transferFrom(sourceCh,0,sourceCh.size());

//关闭相关通道和流

sourceCh.close();

destCh.close();

fileInputStream.close();

fileOutputStream.close();

}

}

---

7、关于 Buffer 和 Channel 的注意事项和细节

ByteBuffer 支持类型化的 put 和 get, put 放入的是什么数据类型，get 就应该使用相应的数据类型来取出，否则可能有 BufferUnderflowException 异常

public class NIOByteBufferPutGet {

public static void main(String[] args) {

//创建一个 Buffer

ByteBuffer buffer = ByteBuffer.allocate(64);

//类型化方式放入数据

buffer.putInt(100);

buffer.putLong(9);

buffer.putChar(‘昌’);

buffer.putShort((short) 4);

//取出，顺序与放入的顺序一致，求类型一致

buffer.flip();

System.out.println();

System.out.println(buffer.getInt());

System.out.println(buffer.getLong());

System.out.println(buffer.getChar());

System.out.println(buffer.getShort());

}

}

• 可以将一个普通 Buffer 转成只读 Buffer

public class ReadOnlyBuffer {

public static void main(String[] args) {

//创建一个 buffer

ByteBuffer buffer = ByteBuffer.allocate(64);

for(int i = 0; i < 64; i++) {//给其放入0-63个数字

buffer.put((byte)i);

}

//读取

buffer.flip();

//得到一个只读的 Buffer

ByteBuffer readOnlyBuffer = buffer.asReadOnlyBuffer();

System.out.println(readOnlyBuffer.getClass());

//读取

while (readOnlyBuffer.hasRemaining()) {//判断是否还有数据

System.out.println(readOnlyBuffer.get());//取出，并给position+1

}

//测试只能读取，不能在put写入

readOnlyBuffer.put((byte)100); //ReadOnlyBufferException

}

}

• NIO 还提供了 MappedByteBuffer， 可以让文件直接在内存（堆外的内存）中进行修改， 而如何同步到文件由 NIO 来完成

/*

说明

1. MappedByteBuffer 可让文件直接在内存(堆外内存)修改, 操作系统不需要拷贝一次

*/

public class MappedByteBufferTest {

public static void main(String[] args) throws Exception {

RandomAccessFile randomAccessFile = new RandomAccessFile(“1.txt”, “rw”);

//获取对应的通道

FileChannel channel = randomAccessFile.getChannel();

/**

• 参数1: FileChannel.MapMode.READ_WRITE 使用的读写模式

• 参数2： 0 ： 可以直接修改的起始位置，字节位置

• 参数3: 5: 是映射到内存的大小(不是索引位置) ,即将 1.txt 的多少个字节映射到内存

• 可以直接修改的范围就是 0-5

• 实际类型 DirectByteBuffer

*/

MappedByteBuffer mappedByteBuffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, 5);

mappedByteBuffer.put(0, (byte) ‘H’);

mappedByteBuffer.put(3, (byte) ‘9’);

mappedByteBuffer.put(5, (byte) ‘Y’);//IndexOutOfBoundsException

//关闭资源

randomAccessFile.close();

System.out.println(“修改成功~~”);

}

}

• NIO 还支持 通过多个 Buffer (即 Buffer 数组) 完成读写操作，即 Scattering 和Gathering

/**

• Scattering：将数据写入到 buffer 时，可以采用 buffer 数组，依次写入 [分散]

• Gathering: 从 buffer 读取数据时，可以采用 buffer 数组，依次读

*/

public class ScatteringAndGatheringTest {

public static void main(String[] args) throws Exception {

//使用 ServerSocketChannel 和 SocketChannel 网络

ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

InetSocketAddress inetSocketAddress = new InetSocketAddress(7000);

//绑定端口到 socket ，并启动

serverSocketChannel.socket().bind(inetSocketAddress);

//创建 buffer 数组

ByteBuffer[] byteBuffers = new ByteBuffer[2];

byteBuffers[0] = ByteBuffer.allocate(5);

byteBuffers[1] = ByteBuffer.allocate(3);

//等客户端连接(telnet)

SocketChannel socketChannel = serverSocketChannel.accept();

int messageLength = 8; //假定从客户端接收 8 个字节

//循环的读取

while (true) {

int byteRead = 0;

while (byteRead < messageLength ) {

long l = socketChannel.read(byteBuffers);

byteRead += l; //累计读取的字节数

System.out.println(“byteRead=” + byteRead);

//使用流打印, 看看当前的这个 buffer 的 position 和 limit

Arrays.asList(byteBuffers).stream().map(buffer -> “postion=” + buffer.position() + “, limit=” + buffer.limit()).forEach(System.out::println);

}

//将所有的 buffer 进行 flip

Arrays.asList(byteBuffers).forEach(buffer -> buffer.flip());

//将数据读出显示到客户端

long byteWirte = 0;

while (byteWirte < messageLength) {

long l = socketChannel.write(byteBuffers); //

byteWirte += l;

}

//将所有的 buffer 进行 clear

Arrays.asList(byteBuffers).forEach(buffer-> {

buffer.clear();

});

System.out.println(“byteRead:=” + byteRead + " byteWrite=" + byteWirte + “, messagelength” + messageLength);

}

}

}

---

六、Selector(选择器)

---

1、基本介绍

1. Java 的 NIO，用非阻塞的 IO 方式。可以用一个线程，处理多个的客户端连接，就会使用到 Selector(选择器)

2. Selector 能够检测多个注册的通道上是否有事件发生(注意:多个 Channel 以事件的方式可以注册到同一个Selector)，如果有事件发生，便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道，也就是管理多个连接和请求。

3. 只有在 连接/通道 真正有读写事件发生时，才会进行读写，就大大地减少了系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程

4. 避免了多线程之间的上下文切换导致的开销

1. Netty 的 IO 线程 NioEventLoop 聚合了 Selector(选择器，也叫多路复用器)，可以同时并发处理成百上千个客户端连接。

2. 当线程从某客户端 Socket 通道进行读写数据时，若没有数据可用时，该线程可以进行其他任务。

3. 线程通常将非阻塞 IO 的空闲时间用于在其他通道上执行 IO 操作，所以单独的线程可以管理多个输入和输出通道。

4. 由于读写操作都是非阻塞的，这就可以充分提升 IO 线程的运行效率，避免由于频繁 I/O 阻塞导致的线程挂起。

5. 一个 I/O 线程可以并发处理 N 个客户端连接和读写操作，这从根本上解决了传统同步阻塞 I/O 一连接一线程模型，架构的性能、弹性伸缩能力和可靠性都得到了极大的提升。

---

2、 Selector 类相关方法

Selector 类是一个抽象类, 常用方法和说明如下:

---

3、注意事项

1. NIO 中的 ServerSocketChannel 功能类似 ServerSocket，SocketChannel 功能类似 Socket

2. selector 相关方法说明

• selector.select()//阻塞

• selector.select(1000);//阻塞 1000 毫秒，在 1000 毫秒后返回

• selector.wakeup();//唤醒 selector

• selector.selectNow();//不阻塞，立马返还

---

4、NIO 非阻塞 网络编程原理分析图

对上图的说明:

1. 当客户端连接时，会通过 ServerSocketChannel 得到 SocketChannel

2. Selector 进行监听 select 方法, 返回有事件发生的通道的个数.

3. 将 socketChannel 注册到 Selector 上, register(Selector sel, int ops), 一个 selector 上可以注册多个 SocketChannel

4. 注册后返回一个 SelectionKey, 会和该 Selector 关联(集合)

5. 进一步得到各个 SelectionKey (有事件发生)

6. 在通过 SelectionKey 反向获取 SocketChannel , 方法 channel()

7. 可以通过 得到的 channel , 完成业务处理

代码：

NIOServer：服务器

public class NIOServer {

public static void main(String[] args) throws Exception{

//创建 ServerSocketChannel -> ServerSocket

ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

//得到一个 Selecor 对象

Selector selector = Selector.open();

//绑定一个端口 6666, 在服务器端监听

serverSocketChannel.socket().bind(new InetSocketAddress(6666));

//设置为非阻塞

serverSocketChannel.configureBlocking(false);

//把 serverSocketChannel 注册到 selector 关心 事件为 OP_ACCEPT

serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

//循环等待客户端连接

while (true) {

//这里我们等待 1 秒，如果没有事件发生, 返回

if(selector.select(1000) == 0) { //没有事件发生

System.out.println(“服务器等待了 1 秒，无连接”);

continue;

}

//如果返回的>0, 就获取到相关的 selectionKey 集合

//1.如果返回的>0， 表示已经获取到关注的事件

//2. selector.selectedKeys() 返回关注事件的集合

// 通过 selectionKeys 反向获取通道

Set selectionKeys = selector.selectedKeys();

//遍历 Set, 使用迭代器遍历

Iterator keyIterator = selectionKeys.iterator();

while (keyIterator.hasNext()) {

//获取到 SelectionKey

SelectionKey key = keyIterator.next();

//根据 key 对应的通道发生的事件做相应处理

if(key.isAcceptable()) { //如果是 OP_ACCEPT, 有新的客户端连接

//该该客户端生成一个 SocketChannel

SocketChannel socketChannel = serverSocketChannel.accept();

System.out.println(" 客 户 端 连 接 成 功 生 成 了 一 个 socketChannel " + socketChannel.hashCode());

//将 SocketChannel 设置为非阻塞

socketChannel.configureBlocking(false);

//将 socketChannel 注册到 selector, 关注事件为 OP_READ， 同时给 socketChannel

//关联一个 Buffer

socketChannel.register(selector, SelectionKey.OP_READ,ByteBuffer.allocate(1024));

}

if(key.isReadable()) { //发生 OP_READ

//通过 key 反向获取到对应 channel

SocketChannel channel = (SocketChannel)key.channel();

//获取到该 channel 关联的 buffer

ByteBuffer buffer = (ByteBuffer)key.attachment();

channel.read(buffer);

System.out.println("form 客户端 " + new String(buffer.array()));

}

//手动从集合中移动当前的 selectionKey, 防止重复操作

keyIterator.remove();

}

}

}

}

NIOClient：客户端

public class NIOClient {

public static void main(String[] args) throws Exception{

//得到一个网络通道

SocketChannel socketChannel = SocketChannel.open();

//设置非阻塞

socketChannel.configureBlocking(false);

//提供服务器端的 ip 和 端口

InetSocketAddress inetSocketAddress = new InetSocketAddress(“127.0.0.1”, 6666);

//连接服务器

if (!socketChannel.connect(inetSocketAddress)) {

while (!socketChannel.finishConnect()) {

System.out.println(“因为连接需要时间，客户端不会阻塞，可以做其它工作…”);

}

}

//…如果连接成功，就发送数据

String str = “hello, 阿昌~”;

//Wraps a byte array into a buffer

ByteBuffer buffer = ByteBuffer.wrap(str.getBytes());

//发送数据，将 buffer 数据写入 channel

socketChannel.write(buffer);

System.in.read();

}

}

---

5、 SelectionKey

• SelectionKey，表示 Selector 和网络通道的注册关系

int OP_ACCEPT：有新的网络连接可以 accept，值为 16

int OP_CONNECT：代表连接已经建立，值为 8

int OP_READ：代表读操作，值为 1

int OP_WRITE：代表写操作，值为 4

源码中：

public static final int OP_READ = 1 << 0;

public static final int OP_WRITE = 1 << 2;

public static final int OP_CONNECT = 1 << 3;

public static final int OP_ACCEPT = 1 << 4;

• SelectionKey 相关方法

---

6、 ServerSocketChannel

ServerSocketChannel 在服务器端监听新的客户端 Socket 连接

专门负责监听新的客户端，获取对应的SocketChannel

---

7、SocketChannel

SocketChannel，网络 IO 通道，具体负责进行读写操作。

NIO 把缓冲区的数据写入通道，或者把通道里的数据读到缓冲区。

---

8、 NIO 网络编程应用实例-群聊系统

• 实例要求

• 编写一个 NIO 群聊系统，实现服务器端和客户端之间的数据简单通讯（非阻塞）

2. 实现多人群聊

3. 服务器端：可以监测用户上线，离线，并实现消息转发功能

4. 客户端：通过 channel 可以无阻塞发送消息给其它所有用户，同时可以接受其它用户发送的消息(有服务器转发

得到)

5. 目的：进一步理解 NIO 非阻塞网络编程机制

代码

• 服务器端

public class GroupChatServer {

//定义属性

private Selector selector;

private ServerSocketChannel listenChannel;

private static final int PORT = 6667;

//构造器

//初始化工作

public GroupChatServer() {

try {

//得到选择器

selector = Selector.open();

//ServerSocketChannel

listenChannel = ServerSocketChannel.open();

//绑定端口

listenChannel.socket().bind(new InetSocketAddress(PORT));

//设置非阻塞模式

listenChannel.configureBlocking(false);

//将该 listenChannel 注册到 selector

listenChannel.register(selector, SelectionKey.OP_ACCEPT);

}catch (IOException e) {

e.printStackTrace();

}

}

//监听

public void listen() {

try {

//循环处理

while (true) {

int count = selector.select();

if(count > 0) {//有事件处理

//遍历得到 selectionKey 集合

Iterator iterator = selector.selectedKeys().iterator();

while (iterator.hasNext()) {

//取出 selectionkey

SelectionKey key = iterator.next();

//监听到 accept

if(key.isAcceptable()) {

SocketChannel sc = listenChannel.accept();

sc.configureBlocking(false);

//将该 sc 注册到 seletor

sc.register(selector, SelectionKey.OP_READ);

//提示

System.out.println(sc.getRemoteAddress() + " 上线 ");

}

if(key.isReadable()) { //通道发送 read 事件，即通道是可读的状态

//处理读 (专门写方法…)

readData(key);

}

//当前的 key 删除，防止重复处理

iterator.remove();

}

} else {

System.out.println(“等待…”);

}

}

}catch (Exception e) {

e.printStackTrace();

}finally {

//发生异常处理…

}

}

//读取客户端消息

private void readData(SelectionKey key) {

//取到关联的 channle

SocketChannel channel = null;

try {

//得到 channel

channel = (SocketChannel) key.channel();

//创建 buffer

ByteBuffer buffer = ByteBuffer.allocate(1024);

int count = channel.read(buffer);

//根据 count 的值做处理

if(count > 0) {

//把缓存区的数据转成字符串

String msg = new String(buffer.array());

//输出该消息

System.out.println("form 客户端: " + msg);

//向其它的客户端转发消息(去掉自己), 专门写一个方法来处理

sendInfoToOtherClients(msg, channel);

}

}catch (IOException e) {

try {

System.out.println(channel.getRemoteAddress() + " 离线了…");

//取消注册

key.cancel();

//关闭通道

channel.close();

}catch (IOException e2) {

e2.printStackTrace();;

}

}

}

//转发消息给其它客户(通道)

private void sendInfoToOtherClients(String msg, SocketChannel self ) throws IOException{

System.out.println(“服务器转发消息中…”);

//遍历 所有注册到 selector 上的 SocketChannel,并排除 self

for(SelectionKey key: selector.keys()) {

//通过 key 取出对应的 SocketChannel

Channel targetChannel = key.channel();

//排除自己

if(targetChannel instanceof SocketChannel && targetChannel != self) {

//转型

SocketChannel dest = (SocketChannel)targetChannel;

//将 msg 存储到 buffer

ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());

//将 buffer 的数据写入 通道

dest.write(buffer);

}

}

}

//主入口

public static void main(String[] args) {

//创建服务器对象

GroupChatServer groupChatServer = new GroupChatServer();

groupChatServer.listen();

}

}

• 客户端

public class GroupChatClient {

//定义相关的属性

private final String HOST = “127.0.0.1”; // 服务器的 ip

private final int PORT = 6667; //服务器端口

private Selector selector;

private SocketChannel socketChannel;

private String username;

//构造器, 完成初始化工作

public GroupChatClient() throws IOException {

selector = Selector.open();

//连接服务器

socketChannel = socketChannel.open(new InetSocketAddress(“127.0.0.1”, PORT));

//设置非阻塞

socketChannel.configureBlocking(false);

//将 channel 注册到 selector

socketChannel.register(selector, SelectionKey.OP_READ);

//得到 username

username = socketChannel.getLocalAddress().toString().substring(1);

System.out.println(username + " is ok…");

}

//向服务器发送消息

public void sendInfo(String info) {

info = username + " 说：" + info;

try {

socketChannel.write(ByteBuffer.wrap(info.getBytes()));

}catch (IOException e) {

e.printStackTrace();

}

}

//读取从服务器端回复的消息

public void readInfo() {

try {

int readChannels = selector.select();

if(readChannels > 0) {//有可以用的通道

Iterator iterator = selector.selectedKeys().iterator();

while (iterator.hasNext()) {

SelectionKey key = iterator.next();

if(key.isReadable()) {

//得到相关的通道

SocketChannel sc = (SocketChannel) key.channel();

//得到一个 Buffer

ByteBuffer buffer = ByteBuffer.allocate(1024);

//读取

sc.read(buffer);

//把读到的缓冲区的数据转成字符串

String msg = new String(buffer.array());

System.out.println(msg.trim());

}

}

iterator.remove(); //删除当前的 selectionKey, 防止重复操作

} else {

//System.out.println(“没有可以用的通道…”);

}

}catch (Exception e) {

e.printStackTrace();

}

}

//主入口

public static void main(String[] args) throws Exception {

//启动我们客户端

GroupChatClient chatClient = new GroupChatClient();

//启动一个线程, 每个 3 秒，读取从服务器发送数据

new Thread() {

public void run() {

while (true) {

chatClient.readInfo();

try {

Thread.currentThread().sleep(3000);

}catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}.start();

//发送数据给服务器端

Scanner scanner = new Scanner(System.in);

while (scanner.hasNextLine()) {

String s = scanner.nextLine();

chatClient.sendInfo(s);

}

}

}

---

NIO 与零拷贝

==================================================================

一、介绍

---

1. 零拷贝是网络编程的关键，很多性能优化都离不开。

2. 在 Java 程序中，常用的零拷贝有 mmap(内存映射) 和 sendFile。那么，他们在 OS 里，到底是怎么样的一个的设计？我们分析 mmap 和 sendFile 这两个零拷贝

3. 另外我们看下 NIO 中如何使用零拷贝

二、传统 IO 数据读写

---

Java 传统 IO 和 网络编程的一段代码

---

三、传统 IO 模型

---

需要切换内核态用户态3次，拷贝4次

DMA: direct memory access 直接内存拷贝(不使用 CPU)

---

四、mmap 优化

---

mmap 通过内存映射，将 文件映射到内核缓冲区，同时， 用户空间可以共享内核空间的数据。

这样，在进行网络传输时，就可以减少内核空间到用户空间的拷贝次数。

但用户态&内核态的切换依然是3次

---

五、sendFile 优化

---

Linux 2.1 版本 提供了 sendFile 函数，其基本原理如下：

数据根本不经过用户态，直接从内核缓冲区进入到Socket Buffer，同时，由于和用户态完全无关，就减少了一次上下文切换

减少了1次用户态内核态的切换，减少1次拷贝次数

零拷贝从操作系统角度，是没有 cpu 拷贝

Linux 在 2.4 版本中，做了一些修改，避免了从 内核缓冲区拷贝到 Socket buffer 的操作，直接拷贝到协议栈，从而再一次减少了数据拷贝。

此时，用户态内核态切换次数2次，拷贝次数1次

这里其实有 一次 cpu 拷贝kernel buffer -> socket buffer

但是，拷贝的信息很少，比如 lenght , offset , 消耗低，可以忽略

---

六、零拷贝的再次理解

---

• 我们说零拷贝，是从操作系统的角度来说的。因为内核缓冲区之间，没有数据是重复的（只有 kernel buffer 有一份数据）。

• 零拷贝不仅仅带来更少的数据复制，还能带来其他的性能优势，例如更少的上下文切换，更少的 CPU 缓存伪共享以及无 CPU 校验和计算。

---

七、mmap 和 sendFile 的区别

---

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

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

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

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）

总结：心得体会

既然选择这个行业，选择了做一个程序员，也就明白只有不断学习，积累实战经验才有资格往上走，拿高薪，为自己，为父母，为以后的家能有一定的经济保障。

学习时间都是自己挤出来的，短时间或许很难看到效果，一旦坚持下来了，必然会有所改变。不如好好想想自己为什么想进入这个行业，给自己内心一个答案。

面试大厂，最重要的就是夯实的基础，不然面试官随便一问你就凉了；其次会问一些技术原理，还会看你对知识掌握的广度，最重要的还是你的思路，这是面试官比较看重的。

最后，上面这些大厂面试真题都是非常好的学习资料，通过这些面试真题能够看看自己对技术知识掌握的大概情况，从而能够给自己定一个学习方向。包括上面分享到的学习指南，你都可以从学习指南里理顺学习路线，避免低效学习。

大厂Java架构核心笔记（适合中高级程序员阅读）：

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

能优势，例如更少的上下文切换，更少的 CPU 缓存伪共享以及无 CPU 校验和计算。

---

七、mmap 和 sendFile 的区别

---

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-XyITAOZ4-1712784346648)]
[外链图片转存中…(img-N8Z4wTuB-1712784346648)]
[外链图片转存中…(img-wsumYj2Q-1712784346649)]
[外链图片转存中…(img-EtfmF0gs-1712784346649)]
[外链图片转存中…(img-jzIChpcg-1712784346649)]
[外链图片转存中…(img-usdxWkqz-1712784346650)]

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

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

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-FsJMDAEq-1712784346650)]

总结：心得体会

既然选择这个行业，选择了做一个程序员，也就明白只有不断学习，积累实战经验才有资格往上走，拿高薪，为自己，为父母，为以后的家能有一定的经济保障。

学习时间都是自己挤出来的，短时间或许很难看到效果，一旦坚持下来了，必然会有所改变。不如好好想想自己为什么想进入这个行业，给自己内心一个答案。

面试大厂，最重要的就是夯实的基础，不然面试官随便一问你就凉了；其次会问一些技术原理，还会看你对知识掌握的广度，最重要的还是你的思路，这是面试官比较看重的。

最后，上面这些大厂面试真题都是非常好的学习资料，通过这些面试真题能够看看自己对技术知识掌握的大概情况，从而能够给自己定一个学习方向。包括上面分享到的学习指南，你都可以从学习指南里理顺学习路线，避免低效学习。

大厂Java架构核心笔记（适合中高级程序员阅读）：

[外链图片转存中…(img-FCFuny3h-1712784346650)]

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
[外链图片转存中…(img-1U9QLfxm-1712784346651)]