【Java校招面试】实战面经（五）

---

前言

“实战面经”是本专栏的第二个部分，本篇博文是第五篇博文，如有需要，可：

1. 点击这里，返回本专栏的索引文章
2. 点击这里，返回上一篇《【Java校招面试】实战面经（四）》
3. 点击这里，前往下一篇《【Java校招面试】实战面经（六）》

---

一、讲讲short数据类型，short s1 = 1; s1 = s1+1;对不对？

1. short类型长度为16位，数据范围为-32768~32767

2. 不对，这个等式的右值需要强制类型转换为short，s1 + 1的时候将s1代表的1转换成了整型做的，想要避免强制转换，用s1++即可。

---

二、使用final关键字的好处

1. final关键字提高了性能。JVM会缓存final变量。
2. final变量可以安全得在多线程环境下进行共享，而不需要额外的同步开销。
3. 使用final关键字，JVM会对方法、变量及类进行优化。

---

三、如果String中重写equals不重写hashCode会出现什么问题？

在HashMap中，通过调用Key的hashCode函数获取哈希值。如果重写了equals不重写hashCode，将String作为Key的时候，HashMap中就有可能存在两个Key相同的键值对，破坏了Key的唯一性。

---

四、ConcurrentHashMap的get方法是不加锁的，如何保证线程安全？

ConcurrentHashMap的get方法不加锁，是因为Node数组用volatile关键字修饰了，一个线程对被volatile修饰的变量进行的修改对其他线程是立即可见的，所以get方法不需要加锁。

---

五、ConcurrentHashMap扩容的过程中，这时候插入的新节点怎么处理？

在 ConcurrentHashMap 的扩容过程中插入新节点时，需要遵循以下步骤：
1. 检查并触发扩容: 当插入新节点时，首先要检查当前是否有一个线程正在执行扩容操作。如果没有线程正在扩容并且当前容量达到了扩容阈值，当前线程可以触发扩容操作。

2. 创建新数组和转发节点: 和 HashMap 类似，在触发扩容后，需要创建一个更大的新数组（新数组的大小通常是原数组大小的两倍）。之后，要在原数组的第一个槽位中创建一个特殊的“转发节点”（forwardingNode），它将指向新的数组。当其他线程处理该槽位时，这个转发节点表示当前正在进行扩容操作。

3. 参与扩容操作: 不论当前线程是否触发了扩容操作，只要正在进行扩容操作，线程就会参与到扩容操作中去。这样可以确保在扩容过程中，其他线程也可以分摊一部分扩容负担。

4. 节点迁移: 迁移节点时，线程不是简单地迁移整个槽位，而是将槽位中的元素平分成几个任务，每个线程根据自己的 ID 和任务总数参与迁移特定的部分。这样，在该阶段，多个线程可以同时参与迁移任务。

5. 插入新节点: 扩容完成后，当前线程会将新节点插入到新的 ConcurrentHashMap 中。这个过程与在没有扩容时直接插入新节点的过程类似，但应使用锁机制（synchronized 或者 Lock 类）确保线程安全。

6. 更新属性和节点: 更新相关属性，如容量、阈值等，本次扩容完成后，将新数组替换原数组。

---

六、LinkedList适合用什么排序？

1. 对于 LinkedList（链表），归并排序（Merge Sort）是一个适合且效率较高的排序算法。归并排序是一种分治算法，原理是不断地将链表分为两个子链表，排序这两个子链表，然后再合并排序好的两个子链表。

2. 原因主要有以下几点:
  1) 非随机访问特性: LinkedList 不支持像数组那样的快速随机访问，获取链表中的任意元素需要顺序遍历。归并排序是一种基于顺序访问的算法，因此与链表的特性相符。

  2) 稳定性: 归并排序是一种稳定的排序算法，这意味着具有相同值的元素在排序后保持原有的相对顺序。

  3) 原地排序: LinkedList 的归并排序可以实现在原地进行，不需要额外的空间复杂度（除了递归调用栈，在非递归实现中没有这些开销，总得来说LinedList的归并排序总体空间复杂度为 O(logn)）

3. 需要注意的是: 对于简单的问题（如较小的链表），插入排序可能更合适，因为插入排序也是顺序访问，而且具有更低的常数时间开销。对于复杂问题（如大型链表），归并排序通常效果更好。

---

七、多线程并发，如何做到子线程都执行结束了主线程才继续往下执行？

1. 对每个子线程调用Thread.join()函数；
2. 使用CountDownLatch，将初始值设为子线程的数量，主线程调用CountDownLatch的wait()函数等待。每个子线程执行结束就countDown，直到计数为0，即每个线程都执行完毕，则主线程继续执行。
3. FutureTask和Callable组合，需要写个死循环用FutureTask轮询线程的状态。

---

八、实现LRU（Least Recently Used，最近最少使用算法）

LinkedHashMap是基于哈希表和双向链表的一个数据结构，它可以按照插入顺序或访问顺序保存元素。因此，通过调整 LinkedHashMap 的配置，我们可以实现 LRU（最近最少使用）算法。

	import java.util.LinkedHashMap;
	import java.util.Map;
	
	public class LRUCache<K, V> extends LinkedHashMap<K, V> {
	    private final int cacheSize;
	
	    public LRUCache(int cacheSize) {
	        super(16, 0.75f, true);
	        this.cacheSize = cacheSize;
	    }
	
	    @Override
	    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
	        return size() > cacheSize;
	    }
	
	    public static void main(String[] args) {
	        LRUCache<Integer, String> cache = new LRUCache<>(3);
	        cache.put(1, "A");
	        cache.put(2, "B");
	        cache.put(3, "C");
			// 访问元素 1
	        cache.get(1);
	        // 添加元素 4，将会导致元素 2 被移除，因为它是最近最少使用的
	        cache.put(4, "D");
	
	        // 打印缓存内容：{3=C, 1=A, 4=D}
	        System.out.println(cache);
	    }
	}

代码说明:

1. 在这个实现中，我们创建了一个名为 LRUCache 的类，继承自 LinkedHashMap。LRUCache 的构造函数接收一个参数 cacheSize，用于设置缓存中允许的元素最大数量。super(16, 0.75f, true) 表示 LinkedHashMap 的初始容量为 16，加载因子为 0.75，使用访问顺序保存元素。
2. 要实现 LRU 算法，我们需要覆盖 removeEldestEntry 方法，它返回一个布尔值，以确定是否应移除最老的条目。
3. 在 main 函数中，我们创建一个包含3个元素的 LRUCache。当我们访问元素 1 后，再添加元素 4 时，最近最少使用的元素 2 将被移除。
4. 在上述示例中，我们实现了一个基于 LRU 策略的键值存储。该存储在达到最大容量时，会自动将最近最少使用的键值对移除。

---

九、JVM内存中程序计数器的作用是什么？

程序计数器用来记录线程当前正在执行的字节码的行号。

---

十、Redis：集群中原始的哈希方法有什么缺点？

增删节点的时候需要对全部的数据重新进行哈希计算（比如原来有5个节点，数据对5取余，去掉一个节点后节点数量变为4，全部数据都要重新对4取余），计算量和数据转移的成本比较大。

---

十一、Socket中的函数

1. 服务端: 建立socket，声明自身的端口号和地址并绑定到socket，使用listen打开监听，然后不断用accept去查看是否有连接，如果有，捕获socket，并通过recv获取消息的内容，通信完成后调用closeSocket关闭这个对应accept到的socket，如果不再需要等待任何客户端连接，那么用closeSocket关闭掉自身的socket。

  1) socket: 加载套接字库，创建套接字文件描述符。
  2) bind: 绑定套接字到一个IP地址和一个端口上。
  3) listen: 将套接字设置为监听模式等待连接请求。
  4) accept: 阻塞等待新的连接，捕获新连接的socket。
  5) send/recv: 用返回的套接字和客户端进行通信。
  6) closesocket: 关闭套接字，关闭加载的套接字库。

2. 客户端: 建立socket，通过端口号和地址确定目标服务器，使用Connect连接到服务器，send发送消息，等待处理，通信完成后调用closeSocket关闭socket。

  1) socket: 加载套接字库，创建套接字。
  2) connect: 向服务器发出连接请求。
  3) send/recv: 和服务器进行通信
  4) closesocket: 关闭套接字，关闭加载的套接字库。

---

十二、SQL中HAVING和WHERE的区别

1. WHERE用于过滤行，HAVING用于过滤分组。
2. WHERE用于在表中做过滤，HAVING对查询结果做过滤，如果HAVING过滤的字段没有跟在SELECT后面，会报错“未知的列”。

---

十三、HTTP常见状态码

• 1xx: 指示信息，表示请求已接收，继续处理
• 2xx: 成功，表示请求已被成功接收、理解、接受
  • 200, OK: 正常返回信息
• 3xx: 重定向，要完成请求必须进行更进一步的操作
  • 301, 永久重定向: 请求的资源永久分配了新的url，以后应使用新url
  • 302, 临时重定向: 请求的资源临时分配了新的url
• 4xx: 客户端错误，请求有语法错误或请求无法实现
  • 400, Bad Request: 客户端请求有语法错误，不能被服务器理解
  • 401, Unauthorized: 请求未经授权，这个状态码必须和WWW-Authenticate报头域一起使用
  • 403, Forbidden: 服务器收到请求，但是拒绝提供服务
  • 404, Not Found: 请求资源不存在
• 5xx: 服务器错误，服务器未能实现合法的请求
  • 500, Internal Server Error: 服务器发生了不可预期的错误
  • 503, Server Unavailable: 服务器当前不能处理客户端的请求，一段时间后可能恢复正常

---

十四、Redis中有序集合的底层实现？跳跃表如何实现？Redis中的跳跃表做了哪些优化？

Redis中的有序集合底层通过跳跃表实现
见《实战面经（四）》第二十五题

---

十五、死锁产生的条件，如何避免死锁？

1. 死锁产生的条件: 互斥、占有且等待、循环等待、非抢占

2. 避免死锁的方法:
  1) 针对占有且等待: 设置锁的优先级，按照一定顺序加锁；
  2) 针对循环等待: 设定超时时间，超时就放弃自己所持有的锁；
  3) 针对非抢占: 系统检测到死锁后，强制一个线程释放掉它持有的锁。

---

十六、会写Shell脚本吗？

会写比较简单的，比如我们的语料库预处理时间比较长，希望执行完之后发个邮件通知。
用mailutils发邮件
echo “邮件正文” | mail -s 邮件主题 收件地址

---

十七、GC Root有哪些？

1. 活跃的线程
2. 虚拟机栈中的变量引用的对象
3. 本地方法栈中的变量引用的对象
4. 方法区中的静态变量和常量引用的对象。

---

十八、设计题：有英雄、小怪、Boss这些角色，设计战斗模块

分为公平战斗（你打我一下，我再打你一下）和即时战斗两种场景

1. 公共的角色类: 需要一个抽象的超类用于抽象出英雄、小怪、Boss等角色的共性，这些角色都是这个超类的子类。

2. 公共的战斗数据工具类: 用于计算攻击、防御、伤害值等数据的工具类

3. 公平战斗: 战斗类，实例化对象时需要传入对战的双方，然后按规则进行对战，直到一方生命值 <= 0.

4. 即时战斗: A攻击B就是A调用B的“掉血”方法，具体的伤害值需要调用战斗数据工具类来计算。

5. 渲染: 前端根据后台的数据变化按照设定的帧率刷新UI。

---

十九、算法题：有一些任务，有的任务有前驱任务，即完成了前驱任务才能开始当前任务，给出一个合理的处理顺序

为解决这个问题，可以使用拓扑排序（Topological Sorting）算法。拓扑排序通常应用于具有部分顺序的任务列表。

	import java.util.*;
	
	public class TopologicalSorting {
	    private int vertices;
	    private LinkedList<Integer> adjacencyList[];
	
	    @SuppressWarnings("unchecked")
	    public TopologicalSorting(int vertices) {
	        this.vertices = vertices;
	        adjacencyList = new LinkedList[vertices];
	        for (int i = 0; i < vertices; i++) {
	            adjacencyList[i] = new LinkedList<>();
	        }
	    }
	
	    public void addEdge(int source, int dest) {
	        adjacencyList[source].add(dest);
	    }
	
	    public void topologicalSorting() {
	        boolean[] visited = new boolean[vertices];
	        Stack<Integer> stack = new Stack<>();
	
	        for (int i = 0; i < vertices; i++) {
	            if (!visited[i]) {
	                DFS(i, visited, stack);
	            }
	        }
	
	        while (!stack.empty()) {
	            System.out.print(stack.pop() + " ");
	        }
	    }
	
	    private void DFS(int vertex, boolean[] visited, Stack<Integer> stack) {
	        visited[vertex] = true;
	
	        for (Integer neighbor : adjacencyList[vertex]) {
	            if (!visited[neighbor]) {
	                DFS(neighbor, visited, stack);
	            }
	        }
	
	        stack.push(vertex);
	    }
	
	    public static void main(String[] args) {
	        TopologicalSorting graph = new TopologicalSorting(6);
	        graph.addEdge(5, 2);
	        graph.addEdge(5, 0);
	        graph.addEdge(4, 0);
	        graph.addEdge(4, 1);
	        graph.addEdge(2, 3);
	        graph.addEdge(3, 1);
	
	        System.out.println("Topological Sorting Order:");
	        graph.topologicalSorting();
	    }
	}

算法说明：

1. 在这个示例中，我们创建了一个名为 TopologicalSorting 的类。TopologicalSorting 类中包含图的顶点数量和邻接列表。addEdge 方法用于向图中添加边。
2. topologicalSorting 方法是实现拓扑排序的主要方法。该方法首先对每个顶点执行深度优先遍历（DFS），并将遍历结束时的顶点压入栈中。遍历所有顶点后，弹出栈中的所有元素，即为拓扑排序后的顺序。
3. 在 main 函数中，我们创建了一个包含 6 个节点（0 到 5）的有向图，并通过 addEdge 方法添加了任务之间的依赖关系。然后调用 topologicalSorting 方法获取任务处理顺序。当程序运行时，它将输出拓扑排序的顺序，确保在执行任务时遵循依赖关系。
4. 需要注意的是: 拓扑排序仅在有向无环图（DAG）中有效。在有环的依赖关系中，任务之间会存在死锁。

---

二十、编程题：在旋转数组中查找最小值的下标，用二分查找优化

    public int findMin(int[] nums) {
        if (nums.length == 1)
            return nums[0];
 
        int left = 0, right = nums.length - 1;
        if (nums[right] > nums[0])
            return nums[0];
 
        while (right >= left) {
            int mid = left + (right - left) / 2;
            if (nums[mid] > nums[mid + 1])
                return nums[mid + 1];
            if (nums[mid - 1] > nums[mid])
                return nums[mid];
 
            if (nums[mid] > nums[0])
                left = mid + 1;
            else
                right = mid - 1;
        }
        return -1;
    }

注: 由于存在索引超界的可能，先排除掉数组长度为1的情况，然后注意right的初值等于length – 1.

---

二十一、Linux进程通信地方式

1. 共享内存
2. 管道
3. 套接字
4. 信号量（Windows没有）
5. 信号（Windows没有）
6. 消息队列（Windows没有）

---

后记

这份面经中对编程写代码的考察比较多，体型也很经典。