任t科技一面

1.自我介绍

个人基本信息 + 校园经历 + 实习经历 + 项目经历 + 个人技能

2.现在在哪里

在公司所在城市+亲人在这边+同学在这边

3.为啥不在实习单位待了

有转正了，但是要内部转岗（实施），还是想干java开发 大模型应用方向方向。

4.工作期间的表现

给转正了，最好的说服

4.大模型生成图片的流程

有一个供用户使用的接口，在数据库查用户的基础信息表，查血糖，血压记录表，进行数据的拼接（用户年龄，BMI 血糖近3葛个月的变化记录），调用AI服务（systemprompt userprompt 拼接）进行数据分析生成要渲染的图形数据，以及对用户健康的建议，获取生成的数据，主要是Echarts 来渲染，以及生成的结论。中间可以说异步的调用RabbitMQ。

5.考勤系统的设计，库表设计，业务实现，AI应用。

6.前端能力

能够利用AI开发提效，（说依赖AI开发，不太好，说可以自己实现前端页面，之不过有一些框架中的一些组件，可能不太熟悉，还要去官网看，效率不太高，但是可以借助AI来提效）

感觉可以在系统的说一下比较好：

熟练html css js ,以及了解开发框架vue,React，以及Ant Design 前端框架开发。在谈谈对前端的看法，AI带来的冲击，以及前后端交互的理解。

7.Mysql 存储引擎

• 一、InnoDB

1. 特点

• 支持事务：InnoDB提供了具有提交、回滚和崩溃恢复能力的事务安全，即ACID（原子性、一致性、隔离性、持久性）兼容的事务支持。
• 行级锁定：InnoDB支持行级锁定，避免了对整个表或大部分表的加锁，提高了并发性能。
• 索引数据结构： 底层是B+树，快速查找数据，降低磁盘IO(只在叶子节点存储数据)，范围查询（叶子节点存储的数据维护一个双向列表）
• 外键约束：InnoDB支持外键约束，确保了数据的完整性和一致性。
• 缓冲池：InnoDB拥有自己的缓冲池，用于在主内存中缓存数据和索引，提高了查询和写入速度。
• 崩溃恢复：InnoDB通过redolog来保证崩溃后的数据恢复，当数据库异常崩溃后，重新启动时会根据redolog进行数据恢复，保证数据库恢复到崩溃前的状态。

2. 适用场景

• 适用于需要高事务完整性和并发性能的应用场景，如电子商务网站、金融系统等。

二、MyISAM

1. 特点

• 不支持事务：MyISAM不支持事务处理和崩溃恢复功能，因此不适用于需要高事务完整性的应用场景。
• 表级锁定：MyISAM只支持表级锁定，并发性能较差，同时读操作会阻塞写操作，写操作也会阻塞读操作（但读操作之间不会相互阻塞）。
• 索引数据结构：和innodb一样采用了基于B+树的索引机制，但是在叶子节点存储的数据只是索引的值而非整行数据。
• 占用空间较小：MyISAM对数据的压缩和文件大小的管理相对简单，因此在数据管理方面能够占用较小的存储空间。
• 全文索引：MyISAM支持全文索引，适用于需要全文搜索的应用场景。

2. 适用场景

• 适用于读操作远远多于写操作的场景，如数据仓库、日志记录等。

三、MEMORY

1. 特点

• 数据存储在内存中：MEMORY存储引擎将数据存储在内存中，因此读写速度非常快。
• 不支持持久化存储：当MySQL服务器关闭或重启时，MEMORY引擎中的数据将丢失，因此不适用于需要长期保存数据的应用场景。
• 支持哈希索引：可以快速查询数据，但是不能范围查询。
• 表级锁定：MEMORY引擎使用表级锁定，可能导致并发性能问题。
• 受限于可用内存大小：由于数据存储在内存中，因此受限于可用的内存大小，如果表过大，可能无法完全缓存在内存中，导致性能下降。

2. 适用场景

• 适用于临时表、缓存表和高性能临时存储，如缓存数据等。

8.数据库能力

建表，sql的多表查询，Sql优化（索引（索引失效），选择合适的字段），良好的sql编写习惯（不使用select * 减少回表 ； 小标驱动大表连接查询），防止SQl注入（预编译+参数注入而不是直接拼接； Druid 的sql防火墙），有拆分思想（对长事务分批处理），主从架构（了解同步原理 - binlog细节）；

了解数据库的锁机制，分库分表思想

9.排序的几种算法

冒泡排序

▼
java
复制代码
public static void bubbleSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n-1; i++) {
        for (int j = 0; j < n-i-1; j++) {
            if (arr[j] > arr[j+1]) {
                // 交换 arr[j] 和 arr[j+1]
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

9.了解哪几种排序算法

快速排序 时间效率 优缺点 稳定性

▼
java
复制代码
public static void quickSort(int[] arr, int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        
        quickSort(arr, low, pi-1);
        quickSort(arr, pi+1, high);
    }
}

private static int partition(int[] arr, int low, int high) {
    int pivot = arr[high];
    int i = low - 1;
    
    for (int j = low; j < high; j++) {
        if (arr[j] < pivot) {
            i++;
            
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
    
    int temp = arr[i+1];
    arr[i+1] = arr[high];
    arr[high] = temp;
    
    return i+1;
}

归并排序

▼
java
复制代码
public static void mergeSort(int[] arr, int l, int r) {
    if (l < r) {
        int m = (l + r) / 2;
        
        mergeSort(arr, l, m);
        mergeSort(arr, m+1, r);
        
        merge(arr, l, m, r);
    }
}

private static void merge(int[] arr, int l, int m, int r) {
    int n1 = m - l + 1;
    int n2 = r - m;
    
    int[] L = new int[n1];
    int[] R = new int[n2];
    
    System.arraycopy(arr, l, L, 0, n1);
    System.arraycopy(arr, m+1, R, 0, n2);
    
    int i = 0, j = 0, k = l;
    
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }
    
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }
    
    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}

11.笔试

▼
java
复制代码
import java.util.*;

class Node {
    Integer id;
    String name;
    List<Node> children;
}

public class Solution {
    public static List<Integer> find_ids_by_name(Node node, String find_name) {
        List<Integer> result = new ArrayList<>();
        dfs(node, find_name, result);
        return result;
    }

    private static void dfs(Node node, String find_name, List<Integer> result) {
        if (node == null) return;
        if (find_name.equals(node.name)) {
            result.add(node.id);
        }
        if (node.children != null) {
            for (Node child : node.children) {
                dfs(child, find_name, result);
            }
        }
    }
}

▼
java
复制代码
编程题五
(
⼝头说下思路
) 
有
100
个⽇志⽂件，每个⽂件⼏⼗个
G
左右，⽇志⽂件由⼀⾏⼀⾏的记录组成，每⼀⾏都能解析出来⼀个
user_id
，计算机内存在⼏百M
级别，
不能⼀⼝⽓放⼊内存进⾏排序
 
要求输⼊是
100个⽇志⽂件的⽂件名，然后所有⽇志按照
user_id
排序好了之后放⼊⼀个⽂件

• 问题本质

• 有 100 个超大日志文件，每个文件几十 GB，总数据远超内存，且每行有 user_id。

• 目标：将所有日志按 user_id 排序，输出到一个新文件。

• 内存有限，不能一次性全部读入排序。

• 解决方案：外部排序（多路归并排序）

• 第一步：分块排序（归并前的准备）

• 依次读取每个大文件的一部分（比如 100MB），将这一部分全部读入内存，按 user_id 排序后写到临时小文件（称为“归并段”）。

• 所有大文件都这样处理，最后会得到很多已排序的小文件。

• 第二步：多路归并

• 用最小堆（优先队列）维护每个小文件的当前最小 user_id 行。

• 每次从堆顶取出最小的 user_id 行，写入输出文件，然后从对应小文件读取下一行放入堆。

• 直到所有小文件都归并完毕。

• 关键点

• 归并时每次只需在内存中维护每个小文件的一行数据，内存消耗极小。

• 归并段数量过多时，可以分批归并，最后再归并一次。

▼
java
复制代码
import java.io.*;
import java.util.*;

public class ExternalSort {

    // 日志行结构体，封装了一行日志内容、userId 以及对应的 BufferedReader
    static class LogLine {
        String line;           // 日志原始内容
        String userId;         // 提取出来的 user_id
        BufferedReader reader; // 该行来自的文件流

        LogLine(String line, BufferedReader reader) {
            this.line = line;
            this.reader = reader;
            // 假设user_id在每行前面，用空格分隔
            this.userId = line.split("\\s+")[0];
        }
    }

    // 分块排序：将大文件分块读入内存，排序后写入临时文件
    public static List<File> splitAndSort(File inputFile, int chunkSizeMB) throws IOException {
        List<File> tempFiles = new ArrayList<>();
        BufferedReader reader = new BufferedReader(new FileReader(inputFile));
        List<String> buffer = new ArrayList<>();
        String line;
        int currentSize = 0;
        while ((line = reader.readLine()) != null) {
            buffer.add(line);
            currentSize += line.length();
            // 达到内存块大小限制，排序并写入临时文件
            if (currentSize >= chunkSizeMB * 1024 * 1024) {
                tempFiles.add(writeSortedChunk(buffer));
                buffer.clear();
                currentSize = 0;
            }
        }
        // 处理最后剩余的数据
        if (!buffer.isEmpty()) {
            tempFiles.add(writeSortedChunk(buffer));
        }
        reader.close();
        return tempFiles;
    }

    // 对内存中的一块数据排序并写入临时文件
    private static File writeSortedChunk(List<String> buffer) throws IOException {
        buffer.sort(Comparator.comparing(s -> s.split("\\s+")[0])); // 按user_id排序
        File tempFile = File.createTempFile("sorted_chunk_", ".txt");
        tempFile.deleteOnExit();
        BufferedWriter writer = new BufferedWriter(new FileWriter(tempFile));
        for (String s : buffer) {
            writer.write(s);
            writer.newLine();
        }
        writer.close();
        return tempFile;
    }

    // 多路归并：将所有已排序的临时文件合并成一个大文件
    public static void mergeSortedFiles(List<File> sortedFiles, File outputFile) throws IOException {
        // 最小堆，按userId排序
        PriorityQueue<LogLine> pq = new PriorityQueue<>(Comparator.comparing(l -> l.userId));
        List<BufferedReader> readers = new ArrayList<>();
        // 初始化，每个文件读取一行放入堆
        for (File file : sortedFiles) {
            BufferedReader reader = new BufferedReader(new FileReader(file));
            readers.add(reader);
            String line = reader.readLine();
            if (line != null) {
                pq.add(new LogLine(line, reader));
            }
        }
        BufferedWriter writer = new BufferedWriter(new FileWriter(outputFile));
        // 不断取出最小userId的行，写入输出文件，并补充新行进堆
        while (!pq.isEmpty()) {
            LogLine min = pq.poll();
            writer.write(min.line);
            writer.newLine();
            String nextLine = min.reader.readLine();
            if (nextLine != null) {
                pq.add(new LogLine(nextLine, min.reader));
            }
        }
        writer.close();
        // 关闭所有文件流
        for (BufferedReader r : readers) r.close();
    }

    // 主入口
    public static void main(String[] args) throws IOException {
        // 假设 args 里是所有日志文件名
        int chunkSizeMB = 100; // 每块100MB
        List<File> allTempFiles = new ArrayList<>();
        // 对每个日志文件分块排序
        for (String filename : args) {
            File inputFile = new File(filename);
            allTempFiles.addAll(splitAndSort(inputFile, chunkSizeMB));
        }
        File outputFile = new File("all_logs_sorted.txt");
        // 多路归并所有临时文件
        mergeSortedFiles(allTempFiles, outputFile);
        System.out.println("排序完成，输出文件: " + outputFile.getAbsolutePath());
    }
}

总结

数据结构知识掌握太差了，挂了.

稍微好一点的公司，就要数据结构以及算法，第一次做这种笔试，真的没思路。感觉刷hot100也做不出来。

数据结构和算法短期提升性价比不高，但是长远来看，数据结构一定要非常熟练，

https://www.bilibili.com/video/BV1E4411H73v?spm_id_from=333.788.videopod.episodes&vd_source=9d2498363dae85df492b06acf5e2dd6c&p=2
近期还是不打算提升，不如去学大模型的应用。