网易日常实习一面面经

1. 自我介绍

2. 两道代码题：

第一道题：写一道链表排序题要求空间复杂度O(1) ：已ac
插入排序算法 时间复杂度 O(N^2)，空间复杂度O(1)

class ListNode{
    int val;
    ListNode next;
    public ListNode(int x) {
        this.val = x;
    }
}
public class LinkedListInsertionSort {
    // 插入排序
    public ListNode insertionSort(ListNode head) {
        if(head == null || head.next == null)
            return head;

        ListNode dummy = new ListNode(0);
        ListNode cur = head;
        // 4 2 1 3
        while(cur != null){
            // 每次从链表的哨兵结点向后寻找插入位置
            ListNode prev = dummy;
            // 在已排序的链表中找到合适的位置插入节点
            while(prev.next != null && prev.next.val < cur.val){
                prev = prev.next;
            }
            // 保存当前链表当中的下一个节点，因为这个节点要进行插入了
            ListNode nextTemp = cur.next;
            // 将 cur 节点插入到 pre 后面
            cur.next = prev.next;
            prev.next = cur;
            // 继续处理下一个节点
            cur = nextTemp;
        }
        return dummy.next;
    }

    public static void main(String[] args) {
        LinkedListInsertionSort sorter = new LinkedListInsertionSort();

        // 创建测试链表 4 -> 2 -> 1 -> 3
        ListNode head = new ListNode(4);
        head.next = new ListNode(2);
        head.next.next = new ListNode(1);
        head.next.next.next = new ListNode(3);

        // 排序
        ListNode sorted = sorter.insertionSort(head);

        // 输出排序后的链表
        while(sorted != null){
            System.out.print(sorted.val + " ");
            sorted = sorted.next;
        }
    }
}

归并排序 时间复杂度O(nlogn) , 空间复杂度O(nlogn) 。当然这道题不可以使用这个算法。

第二道题：写出可以StackOverFlow的代码

public class StackOverFlow {
    public static void main(String[] args) {
        dfs();
    }

    private static void dfs() {
        dfs();
    }
}

3. 讲一讲自己项目当中那部分是比较有成就感的。

那我就讲一下第一个项目：基于微服务架构的社区社交平台：
我认为在笔记服务当中：首先我先测试的仅使用了 Mysql 数据库存储和读取数据的接口设计，并用Jmeter 压测单机单节点，发现在本地运行笔记发布删除的吞吐量仅有 10000+/ s ,响应耗时也较高，此时我选择引用 Redis分布式缓存来对数据库查询修改接口之前加上一段缓存，此时吞吐量提升了近1倍，后面我又在Redis之前添加Caffeine 的本地缓存，吞吐量又有较高的提升。但是此时产生了二级缓存结构与Mysql数据库数据不一致的问题。因此我采取在读取记录的读策略时发现缓存当中不存在的情况下先查询数据库在添加到缓存当中。在更新、删除记录时，使用 RocketMQ 广播服务，实现集群环境下，对本地缓存中缓存的删除，达到数据一致性。并且在点赞接口支持高并发写：使用 Redis Bloom 布隆过滤器，高性能判断用户是否点赞，通过 Redis ZSET + MQ 异步落库，消费者中使用 RateLimiter 令牌桶实现流量削峰，避免了缓存雪崩，缓存穿透，缓存击穿等问题；
在用户关系服务当中：通过 Redis 缓存 + 发送顺序消息 MQ 异步存库，实现接口的高并发写与操作的顺序性，使用 Lua 脚本，避免频繁操作 Redis 造成的性能瓶颈，且保证多次操作的原子性；消费者使用联合唯一索引保证关系记录的幂等性；

4. 加入说有个用户进行了点赞，怎么统计某个笔记和内容的点赞数量

首先使用 Redis Bloom 布隆过滤器，高性能判断用户是否点赞：然后发送MQ消息，将点赞落数据落库：最后调用计数服务通过聚合操作将数据落入数据库。

5.怎样处理中间件的消息积压问题？

发生了消息积压，这时候就得想办法赶紧把积压的消息消费完，就得考虑提高消费能力，一般有两种办法：
消息积压处理

消费者扩容： 如果当前 Topic 的 Message Queue 的数量大于消费者数量，就可以对消费者进行扩容，增加消费者，来提高消费能力，尽快把积压的消息消费玩。
消息迁移 Queue 扩容： 如果当前 Topic 的 Message Queue 的数量小于或者等于消费者数量，这种情况，再扩容消费者就没什么用，就得考虑扩容 Message Queue。可以新建一个临时的 Topic，临时的 Topic 多设置一些 Message Queue，然后先用一些消费者把消费的数据丢到临时的 Topic，因为不用业务处理，只是转发一下消息，还是很快的。接下来用扩容的消费者去消费新的 Topic 里的数据，消费完了之后，恢复原状。

6. Java基础

6.1

	String a = "abc";
    String b = new String("abc");
    String c = new String("abc");
    String d = "abc";
    System.out.println(a == b);
    System.out.println(b == c);
    System.out.println(c == d);
    System.out.println(d == a);

这几个用==判断是否相同，首先在字符串常量池当中创建字符串 "abc" 所以 a, d都是指向的字符串常量池的地址，b,c都是在堆上new出来的结果，由于a = "abc"先执行，所以都在堆中的对象指向字符串常量池中的地址，但是他们这两个对象地址又不相同，所以a = d, a != b, b != c, a != c。

6.2 假如当前有一个对象，要重写euqals方法，在重写euqals方法的时候要注意什么？

在重写 equals 方法时，一定要重写 hashCode 方法。equals 和 hashCode 之间有一个重要的契约：

如果两个对象通过 equals 比较结果相等，则它们的 hashCode 也必须相等。
如果两个对象通过 equals 比较结果不相等，它们的 hashCode 不一定要不同，但建议尽量不同，以提高性能。

例如String类当中重写了euqals方法，他会首先判断两个对象是否是同一个对象，即==来判断，通过这个判断的原理就是计算两个对象的hashcode是否相同。如果相同直接返回true,不同再回判断是否类型相同长度相同，里面的元素相同等等。

如何遍历一个Map，我想要拿到他们所有的key所有的value

在 Java 中，遍历 Map 可以通过多种方式来实现。你可以选择遍历 Map 的所有键 (key)，值 (value)，或者键值对 (key-value pair)。
以下是几种常见的遍历 Map 的方式，适用于任何实现了 Map 接口的类（如 HashMap、TreeMap 等）。

1. 使用 for-each 和 entrySet()（推荐方式）

entrySet() 方法返回 Map 中所有键值对的集合 (Set<Map.Entry<K, V>>)，你可以通过这种方式高效地遍历 Map 的所有键值对。

Map<String, String> map = new HashMap<>();
map.put("a", "apple");
map.put("b", "banana");
map.put("c", "cherry");

// 遍历 key-value 对
for (Map.Entry<String, String> entry : map.entrySet()) {
    String key = entry.getKey();
    String value = entry.getValue();
    System.out.println("Key: " + key + ", Value: " + value);
}

2. 使用 for-each 和 keySet()

keySet() 方法返回 Map 中所有的键（Set），你可以通过这种方式获取所有键，并使用 get() 方法获取对应的值。

Map<String, String> map = new HashMap<>();
map.put("a", "apple");
map.put("b", "banana");
map.put("c", "cherry");

// 遍历所有键，然后获取值
for (String key : map.keySet()) {
    String value = map.get(key);
    System.out.println("Key: " + key + ", Value: " + value);
}

3. 使用 for-each 和 values()（仅遍历值）

如果你只对值感兴趣，而不关心具体的键，可以使用 values() 方法，它返回一个 Collection，包含 Map 中的所有值。

Map<String, String> map = new HashMap<>();
map.put("a", "apple");
map.put("b", "banana");
map.put("c", "cherry");

// 仅遍历值
for (String value : map.values()) {
    System.out.println("Value: " + value);
}

4. 使用 Iterator 遍历 entrySet()

如果你需要在遍历过程中进行删除操作或者有特殊的遍历需求，可以使用 Iterator。

Map<String, String> map = new HashMap<>();
map.put("a", "apple");
map.put("b", "banana");
map.put("c", "cherry");

// 使用 Iterator 遍历 key-value 对
Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
    Map.Entry<String, String> entry = iterator.next();
    String key = entry.getKey();
    String value = entry.getValue();
    System.out.println("Key: " + key + ", Value: " + value);
}

5. Java 8 Stream API（现代方式）

如果你使用的是 Java 8 或更高版本，Stream API 可以为你提供更简洁的代码风格。

Map<String, String> map = new HashMap<>();
map.put("a", "apple");
map.put("b", "banana");
map.put("c", "cherry");

// 使用 Java 8 Stream API 遍历
map.forEach((key, value) -> System.out.println("Key: " + key + ", Value: " + value));

7. JUC

7.1 假设有一个发音引擎：部署在本地最多只支持32路并发，假设有第33个请求进入翻译引擎，请问怎样实现这个业务？

可以通过阻塞队列或者是信号量来实现这个需求：
信号量实现就32个信号，没有了就阻塞

8. Linux

8.1 讲一下tail命令

tail 命令用于查看文件的末尾内容，默认情况下显示文件的最后 10 行。
语法

tail [OPTION]... [FILE]...

常用选项

选项	说明
-n N	显示文件的最后 N 行
-f	监听文件内容变化，实时输出新增内容（常用于日志文件）
-c N	显示文件的最后 N 字节
-q	静默模式，不输出文件名
-v	始终输出文件名
使用示例