大厂面试 | 百度一面，顶不住

题目来源：https://www.nowcoder.com/feed/main/detail/d39aabc0debd4dba810b4b9671d54348

前文

本期是【捞捞面经 】系列文章的第 2 期，持续更新中...。（更多与往期下方仓库直达 ）

《捞捞面经》系列正式开始连载啦，据说看了这个系列的朋友都拿到了大厂offer~

• 你是否看面经只有问题没有解析？是否缺乏实时一线大厂面经攻略？捞捞面经帮你解决~
• 欢迎星标+订阅，持续更新中。。。致力打造校招核心面试攻略~
• NowcoderTop: 汇总收录牛客各互联网大厂实时高频面经攻略（含详解）🔥（欢迎投稿~） ：https://github.com/xlcoding/NowcoderTop

捞捞面经

注：养成先看真题，自己模拟回答，再看解析参考（别忘随手一键三连哦~）

1.基础题

• 有几种网络io模型？
• 异步网络模型在什么场景下你了解有应用过？（回答了线程相关的场景）
• 除了用线程完成，还有什么操作可以完成异步操作？
• 同步阻塞和同步非阻塞在Java层面怎么实现？（说前面网络io模型答得挺顺畅，具体实现细节还需要提升一下）
• 描述一下一次完整的 Http 请求
• 知道的长连接有几种实现方式？
• 一个 Http 请求包含哪几部分内容？

2.代码题

• 设计一个 HashSet（完全不会）

3.场景题

• 1T 的数据怎么加载到 200M 的内存中，并且找到两行一样的数据？
• Java 打开 1T 文件，第一部操作做什么？
• 用代码打开一个文件和用鼠标打开一个文件有什么区别？

注意：博主基础题即不过多介绍，只选经典题目分析。

你了解哪些网络 IO 模型？

常见的网络IO模型有以下几种：

1. 阻塞式IO模型（Blocking IO Model）：在这种模型中，当一个线程执行一个 IO 操作时，它会一直阻塞，直到 IO 操作完成。
2. 非阻塞式IO模型（Non-Blocking IO Model）：在这种模型中，当一个线程执行一个IO操作时，它不会一直阻塞，而是会立即返回，告诉调用者 IO 操作是否完成。
3. 多路复用IO模型（Multiplexed IO Model）：一个线程可以同时监视多个 IO 操作，当有一个 IO 操作完成时，它会通知线程进行处理。
4. 信号驱动式IO模型（Signal Driven IO Model）：在这种模型中，当一个 IO 操作完成时，操作系统会向应用程序发送一个信号，应用程序在接收到信号后进行处理。
5. 异步IO模型（Asynchronous IO Model）：应用程序发起一个 IO 操作后，不需要等待操作完成，而是可以继续执行其他操作，当 IO 操作完成后，操作系统会通知应用程序进行处理。

异步网络模型你在什么场景下使用过，具体可以应用到哪些地方？

1. 高并发的Web应用程序：在Web应用程序中，异步网络模型可以提高服务器的并发处理能力，减少线程的阻塞等待时间，提高系统的吞吐量。
2. 高性能的网络服务器 ：在网络服务器中，异步网络模型可以提高服务器的并发处理能力，减少线程的阻塞等待时间，提高系统的吞吐量。
3. 大规模的实时数据处理系统：在实时数据处理系统中，异步网络模型可以提高数据的处理效率，减少数据处理的延迟时间，提高系统的实时性。
4. 大规模的分布式系统 ：在分布式系统中，异步网络模型可以提高系统的并发处理能力，减少线程的阻塞等待时间，提高系统的吞吐量。

异步网络模型可以应用于任何需要高并发、高性能、高实时性的场景，以提高系统的性能和可扩展性，提高用户体验。

能结合具体业务场景举个例吗？

异步网络模型在社交和购物等场景下也非常常见。比如：

1. 社交应用程序：在社交应用程序中，异步网络模型可以用于处理用户的聊天消息、动态更新等请求，提高系统的实时性和性能。
2. 购物网站 ：在购物网站中，异步网络模型可以用于处理用户的订单、支付、物流等请求，提高系统的并发处理能力和性能。

举个具体实际的例子，常常玩的 王者荣耀。（个人看法 ）它需要处理大量的游戏玩家请求，包括登录、注册、查询游戏数据、游戏操作等。如果使用阻塞式IO模型，每个请求都需要创建一个线程来处理，当并发请求量较大时，线程的创建和销毁会带来很大的开销，导致服务器的性能和吞吐量下降。

而如果使用异步网络模型，可以通过 事件驱动的方式处理请求 ，当有玩家请求到达时，服务器不需要创建新的线程，而是通 过异步IO操作来处理请求，当IO操作完成后，服务器会回调相应的处理函数进行处理，这样可以大大减少线程的创建和销毁开销，提高服务器的性能和吞吐量。

另外，异步网络模型还可以应用于实时数据处理系统，比如金融交易系统、在线广告系统等，这些系统需要实时处理大量的数据请求，如果使用阻塞式IO模型，会导致数据处理的延迟时间较长，影响系统的实时性。而使用异步网络模型，可以通过事件驱动的方式实时处理数据请求，提高系统的实时性和性能。

怎样可以完成异步操作？

1. 回调函数 ：在 Java 中，可以使用回调函数的方式来完成异步操作，比如使用 Java 的回调接口或者 Lambda 表达式来实现异步回调。
2. Future对象 ：Future 对象是 Java 中的一种异步编程解决方案，它可以将异步操作封装成一个 Future 对象，然后使用 Future.get() 方法来等待异步操作的完成，从而实现异步操作的同步化编程。
3. CompletableFuture对象 ：CompletableFuture是Java 8中新增的异步编程解决方案，它可以将异步操作封装成一个 CompletableFuture 对象，然后使用 CompletableFuture的方法来处理异步操作的结果，比如 thenApply()、thenAccept()、thenRun()等方法。
4. 异步框架 ：可以采用一些异步框架可以用于实现异步操作，比如Netty、Vert.x等框架，它们可以通过事件驱动的方式实现异步操作，提高系统的性能和可扩展性。

在Java中，同步阻塞和同步非阻塞可以通过不同的IO模型来实现？

在Java中，同步阻塞和同步非阻塞可以通过不同的 IO 模型来实现。

1. 同步阻塞 IO 模型：在Java中，同步阻塞 IO 模型是最常见的 IO 模型，它使用 InputStream 和 OutputStream 等阻塞式 IO 类来实现数据的读写操作。在同步阻塞 IO 模型中，当一个线程调用阻塞式 IO 类的 read() 或 write() 方法时，该线程会被阻塞，直到IO操作完成或者出现异常。
2. 同步非阻塞 IO 模型：在Java中，同步非阻塞 IO 模型可以通过使用Java NIO（New IO）来实现。Java NIO 提供了一种基于通道和缓冲区的IO模型，可以实现非阻塞式的IO操作。在同步非阻塞 IO 模型中，当一个线程调用 Java NIO 的通道的 read() 或 write() 方法时，该线程不会被阻塞，而是立即返回，然后可以通过轮询的方式来检查 IO 操作的状态，从而实现非阻塞式的 IO 操作。

能结合具体场景讲解吗？

当涉及到高并发、高性能、高可靠性的场景时，选择合适的 IO 模型非常重要。下面结合具体场景来讲解：

1. Web服务器：对于 Web 服务器来说，同步阻塞 IO 模型是最常用的IO模型，因为它可以提供稳定的性能和可靠性。在Java中，可以使用Servlet API来实现同步阻塞 IO 模型。如果需要更高的性能和可扩展性，可以考虑使用异步 IO 模型，比如 Java NIO 或者 Netty 等框架。
2. 游戏服务器 ：对于游戏服务器来说，需要处理大量的并发连接和实时数据交互，因此同步非阻塞 IO 模型是比较适合的选择。在Java中，可以使用 Java NIO 或者 Netty 等框架来实现同步非阻塞IO模型。
3. 数据库访问：对于数据库访问来说，同步阻塞IO模型是最常用的IO模型，因为它可以提供稳定的性能和可靠性。在 Java中，可以使用JDBC API 来实现同步阻塞 IO 模型。如果需要更高的性能和可扩展性，可以考虑使用异步 IO 模型，比如使用异步数据库驱动程序，比如HikariCP等。

除了同步阻塞和同步非阻塞 IO 模型之外，还有一些其他的 IO 模型，比如异步IO模型、多路复用IO模型等。在实际应用中，应该根据具体的场景和需求来选择合适的 IO 模型。

描述一下一次完整的 Http 请求？

一次完整的HTTP请求通常包括以下步骤：(如果是从浏览器发起地址请求，还需要地址各种解析哦～)

1. 建立 TCP 连接 ：客户端通过 TCP 协议与服务器建立连接，进行 "三次握手"。客户端发送 SYN 包，服务器回应 SYN+ACK 包，客户端再回应 ACK 包，完成连接建立。
2. 发送 HTTP 请求 ：客户端向服务器发送 HTTP 请求，请求中包含请求行、请求头和请求体。请求行包括请求方法、请求URL和HTTP协议版本；请求头包括一些附加信息，比如请求头部字段、Cookie 等；请求体包含请求的数据，比如POST请求中的表单数据。
3. 服务器处理请求：服务器接收到客户端发送的 HTTP 请求后，会根据请求的内容进行处理，比如查询数据库、读取文件等。
4. 服务器返回 HTTP 响应：服务器处理完请求后，会向客户端返回 HTTP 响应，响应中包含响应行、响应头和响应体。响应行包括 HTTP 协议版本、状态码和状态描述；响应头包括一些附加信息，比如响应头部字段、Cookie 等；响应体包含响应的数据，比如 HTML 页面、JSON 数据等。
5. 关闭TCP连接 ：客户端接收到服务器返回的HTTP响应后，会关闭TCP连接，进行 "四次挥手"。客户端发送 FIN 包，服务器回应 ACK 包，然后服务器发送 FIN 包，客户端回应ACK 包，完成连接关闭。

总之，一次完整的 HTTP 请求包括建立 TCP 连接、发送 HTTP 请求、服务器处理请求、服务器返回 HTTP 响应和关闭 TCP 连接等步骤。在实际应用中，还需要考虑 HTTP 缓存、Cookie、会话管理等问题。

长连接有哪些实现方式？

• 长连接是指客户端和服务器之间保持连接状态，可以在一定时间内进行多次请求和响应，而不必每次请求都重新建立连接。
• 长连接可以减少连接建立和断开的开销，提高网络传输效率，常用于实时通信、推送服务等场景。

常见的长连接实现方式包括：

1. HTTP长连接 ：HTTP/1.1 协议支持长连接，客户端和服务器之间可以保持连接状态，可以在一定时间内进行多次请求和响应。在 HTTP 长连接中，客户端发送请求后，服务器会保持连接状态，直到客户端发送关闭连接的请求或者超时时间到达。
2. WebSocket ：WebSocket 是一种基于 HTTP 协议的长连接技术，它可以在客户端和服务器之间建立双向通信的连接，实现实时通信和推送服务。WebSocket 协议通过 HTTP协议的升级实现，客户端和服务器之间可以发送和接收数据帧，而不必重新建立连接。
3. TCP长连接 ：TCP 协议支持长连接，客户端和服务器之间可以保持连接状态，可以在一定时间内进行多次请求和响应。在TCP长连接中，客户端和服务器之间建立连接后，可以保持连接状态，直到客户端或服务器发送关闭连接的请求或者网络异常断开连接。

长连接可以提高网络传输效率，常用于实时通信、推送服务等场景

设计一个Hashset？

我随便设计的一个简单的 Hashset（仅供参考）：

1. 定义一个哈希表数组，数组的长度为质数，每个元素是一个链表，用于存储哈希冲突的元素。
2. 定义一个哈希函数，将元素映射到哈希表数组中的一个位置。可以使用取模运算或者位运算等方式实现哈希函数。
3. 实现添加元素的方法。首先根据哈希函数计算元素的哈希值，然后将元素添加到对应位置的链表中。如果链表中已经存在相同的元素，则不添加。
4. 实现删除元素的方法。首先根据哈希函数计算元素的哈希值，然后在对应位置的链表中查找元素，如果找到则删除。
5. 实现查找元素的方法。首先根据哈希函数计算元素的哈希值，然后在对应位置的链表中查找元素，如果找到则返回元素，否则返回null。
6. 实现获取元素个数的方法。遍历哈希表数组，统计所有链表中元素的个数。
7. 实现清空哈希表的方法。遍历哈希表数组，将所有链表清空。

下面是一个简单的Java代码实现：

public class MyHashSet<T> {
    private static final int DEFAULT_CAPACITY = 16;
    private static final float DEFAULT_LOAD_FACTOR = 0.75f;

    private Node<T>[] table;
    private int size;
    private int threshold;
    private float loadFactor;

    public MyHashSet() {
        this(DEFAULT_CAPACITY, DEFAULT_LOAD_FACTOR);
    }

    public MyHashSet(int initialCapacity, float loadFactor) {
        table = new Node[initialCapacity];
        this.loadFactor = loadFactor;
        threshold = (int) (initialCapacity * loadFactor);
    }

    public boolean add(T value) {
        int hash = hash(value);
        int index = indexFor(hash, table.length);
        Node<T> node = table[index];
        while (node != null) {
            if (node.value.equals(value)) {
                return false;
            }
            node = node.next;
        }
        Node<T> newNode = new Node<>(value, table[index]);
        table[index] = newNode;
        size++;
        if (size > threshold) {
            resize(table.length * 2);
        }
        return true;
    }

    public boolean remove(T value) {
        int hash = hash(value);
        int index = indexFor(hash, table.length);
        Node<T> node = table[index];
        Node<T> prev = null;
        while (node != null) {
            if (node.value.equals(value)) {
                if (prev == null) {
                    table[index] = node.next;
                } else {
                    prev.next = node.next;
                }
                size--;
                return true;
            }
            prev = node;
            node = node.next;
        }
        return false;
    }

    public boolean contains(T value) {
        int hash = hash(value);
        int index = indexFor(hash, table.length);
        Node<T> node = table[index];
        while (node != null) {
            if (node.value.equals(value)) {
                return true;
            }
            node = node.next;
        }
        return false;
    }

    public int size() {
        return size;
    }

    public void clear() {
        Arrays.fill(table, null);
        size = 0;
    }

    private int hash(T value) {
        return value.hashCode();
    }

    private int indexFor(int hash, int length) {
        return hash & (length - 1);
    }

    private void resize(int newCapacity) {
        Node<T>[] newTable = new Node[newCapacity];
        for (Node<T> node : table) {
            while (node != null) {
                Node<T> next = node.next;
                int index = indexFor(hash(node.value), newCapacity);
                node.next = newTable[index];
                newTable[index] = node;
                node = next;
            }
        }
        table = newTable;
        threshold = (int) (newCapacity * loadFactor);
    }

    private static class Node<T> {
        T value;
        Node<T> next;

        public Node(T value, Node<T> next) {
            this.value = value;
            this.next = next;
        }
    }
}

1T 的数据怎么加载到 200M 的内存中，并找到两行一样的数据？

将 1T 的数据加载到 200M 的内存中是不可能的，因为1T 的数据远远超过了 200M 的内存大小。因此，需要采用一些特殊的算法和技术来解决这个问题。

一种解决方案是使用 外部排序算法 ，将1T的数据分成多个小文件，每个小文件可以加载到内存中进行排序。然后，使用归并排序的思想将这些小文件合并成一个大文件，并在合并的过程中找到两行一样的数据。

具体步骤如下（参考）：

1. 将 1T 的数据分成多个小文件，每个小文件的大小为 200M
2. 对每个小文件进行排序，可以使用快速排序等算法。
3. 将排序后的小文件合并成一个大文件，可以使用归并排序的思想。
4. 在合并的过程中，记录前一个文件的最后一行和当前文件的第一行，比较这两行是否相同，如果相同则找到了两行一样的数据。
5. 最后，将找到的两行一样的数据输出即可。

而在实际操作中，还需要考虑磁盘读写速度、文件的读写方式等因素，以提高算法的效率和准确性。

Java打开 1T 的文件，第一步做什么？

在 Java 中打开 1T 的文件，第一步应该是确定文件的读取方式和读取范围。

1. 确定文件的读取方式：根据文件的类型和大小，选择适当的文件读取方式。如果文件是文本文件，可以使用 BufferedReader 逐行读取；如果文件是二进制文件，可以使用DataInputStream 或者 FileChannel 进行读取。
2. 确定文件的读取范围：由于1T的文件非常大，无法一次性读取到内存中，因此需要确定读取的范围。可以将文件分成多个块，每次读取一个块的数据，处理完后再读取下一个块的数据。可以根据文件的大小和内存的大小来确定块的大小。

用代码打开一个文件和用鼠标打开用什么区别吗？

其底层区别主要在于操作系统和文件系统的交互方式。

用鼠标打开文件是通过操作系统提供的图形用户界面(GUI)来实现的，用户点击图标，但实际操作系统会根据用户的操作来调用相应的API，从而实现文件的打开、读取、写入等操作。而这些 API 实际通常是操作系统提供的底层文件系统接口 ，例如 Windows 的 Win32 API、Linux 的 POSIX API 等。

而用代码打开文件则是 **通过编程语言提供的文件操作API **来实现的，这些API通常是对操作系统底层文件系统接口的封装和抽象。通常可以使用 File、FileInputStream、FileOutputStream 等类来实现文件的打开、读取、写入等操作，这些类会调用底层的操作系统文件系统接口来实现相应的功能。

因此，从底层的角度来看，用代码打开文件和用鼠标打开文件的区别在于调用的API不同，但底层的文件系统接口是相同的。

一次 Http 请求包含哪几部分内容？

1. 请求行 （Request Line）：包含请求方法、请求的URL和HTTP协议版本。常见的请求方法有 GET、POST、PUT、DELETE 等。
2. 请求头部 （Request Headers）：包含请求的各种头部信息，例如 User-Agent、Content-Type、Cookie 等。头部信息提供了关于请求的附加信息，用于服务器处理请求。
3. 请求体 （Request Body）：对于 GET 请求，请求体通常为空。对于 POST 请求等需要传递数据的请求，请求体包含了要发送给服务器的数据。

原文收录：https://github.com/xlcoding/NowcoderTop