1. 自我介绍

我是一名有X年经验的Java开发工程师，熟练掌握Java核心技术、多线程编程、JVM原理、数据结构和算法。在XX领域有丰富的项目经验，熟悉Spring全家桶、分布式系统开发等。

2. Java的特征

• 面向对象：封装、继承、多态

• 平台无关性：一次编写，到处运行（Write Once, Run Anywhere）

• 安全性：内置安全机制，如字节码验证、安全管理器

• 多线程：内置多线程支持

• 健壮性：强类型、异常处理、垃圾回收

• 分布式：支持网络编程和分布式应用

3. 多态

多态是指同一操作作用于不同的对象，可以有不同的解释和不同的执行结果。主要包括：

• 编译时多态：方法重载

• 运行时多态：方法重写，通过继承和接口实现

4. JMM（Java内存模型）介绍

JMM定义了Java程序中各种变量（线程共享变量）的访问规则，以及在JVM中将变量存储到内存和从内存中读取变量的底层细节。

• 主内存：所有共享变量都存储在主内存中

• 工作内存：每个线程有自己的工作内存，保存该线程使用到的变量的主内存副本

• 内存间交互操作：read、load、use、assign、store、write

5. JVM为什么频繁GC

• 对象创建和销毁频繁

• 内存分配不合理

• 存在内存泄漏

• 堆内存设置过小

• 代码中存在大量短生命周期对象

6. 进程间通信（Android App间通信）

• Intent：最常用的通信方式

• ContentProvider：数据共享

• BroadcastReceiver：广播通信

• AIDL：跨进程方法调用

• Messenger：基于消息的通信

• 文件共享

• Socket通信

7. BIO、NIO、AIO

• BIO：同步阻塞IO，一个连接一个线程

• NIO：同步非阻塞IO，基于通道和缓冲区，使用选择器

• AIO：异步非阻塞IO，基于事件和回调

8. NIO核心组件

• Channel：通道，数据的双向传输通道

• Buffer：缓冲区，数据容器

• Selector：选择器，多路复用器

9. 二叉树遍历

前序遍历：根→左→右

java

void preOrder(TreeNode root) {
    if (root != null) {
        System.out.print(root.val + " ");
        preOrder(root.left);
        preOrder(root.right);
    }
}

中序遍历：左→根→右

java

void inOrder(TreeNode root) {
    if (root != null) {
        inOrder(root.left);
        System.out.print(root.val + " ");
        inOrder(root.right);
    }
}

后序遍历：左→右→根

java

void postOrder(TreeNode root) {
    if (root != null) {
        postOrder(root.left);
        postOrder(root.right);
        System.out.print(root.val + " ");
    }
}

层序遍历：使用队列

java

void levelOrder(TreeNode root) {
    if (root == null) return;
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);
    while (!queue.isEmpty()) {
        TreeNode node = queue.poll();
        System.out.print(node.val + " ");
        if (node.left != null) queue.offer(node.left);
        if (node.right != null) queue.offer(node.right);
    }
}

10. 统计文件字符出现次数

java

public Map<Character, Integer> countChars(String filename) throws IOException {
    Map<Character, Integer> map = new HashMap<>();
    try (BufferedReader reader = new BufferedReader(new FileReader(filename))) {
        int ch;
        while ((ch = reader.read()) != -1) {
            char c = (char) ch;
            map.put(c, map.getOrDefault(c, 0) + 1);
        }
    }
    return map;
}

11. 约瑟夫环问题

java

public int josephus(int n) {
    if (n <= 0) return -1;
    
    List<Integer> list = new ArrayList<>();
    for (int i = 1; i <= n; i++) {
        list.add(i);
    }
    
    int index = 0;
    while (list.size() > 1) {
        index = (index + 2) % list.size(); // 每3个人踢第3个
        list.remove(index);
    }
    return list.get(0);
}

12. List、Set、Map

• List：有序、可重复

• Set：无序、不可重复

• Map：键值对，键不可重复

13. HashMap和TreeMap

• HashMap：基于哈希表，无序，O(1)时间复杂度

• TreeMap：基于红黑树，有序，O(log n)时间复杂度

14. Vector

线程安全的动态数组，方法使用synchronized修饰，性能较低。

15. ArrayList和LinkedList

• ArrayList：基于数组，随机访问快，增删慢

• LinkedList：基于链表，随机访问慢，增删快

16. HashMap和LinkedHashMap

• HashMap：无序

• LinkedHashMap：保持插入顺序或访问顺序

17. JVM栈内存和堆内存泄露处理

栈内存泄露：

• 检查递归深度

• 检查局部变量表大小

堆内存泄露：

• 使用jmap、jstat等工具分析

• 检查未关闭的资源

• 检查静态集合类

• 使用内存分析工具（MAT）

18. NIO读取数据位置

NIO读取数据可以放在：

• 堆内存：HeapByteBuffer

• 直接内存：DirectByteBuffer（零拷贝，不经过JVM堆）

19. 快速排序

java

public void quickSort(int[] arr, int low, int high) {
    if (low < high) {
        int pivot = partition(arr, low, high);
        quickSort(arr, low, pivot - 1);
        quickSort(arr, pivot + 1, high);
    }
}

private 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++;
            swap(arr, i, j);
        }
    }
    swap(arr, i + 1, high);
    return i + 1;
}

20. 二分查找

java

public int binarySearch(int[] arr, int target) {
    int left = 0, right = arr.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] == target) return mid;
        else if (arr[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

21. JVM崩溃原因查找

• 查看hs_err_pid日志文件

• 分析dump文件

• 检查系统资源

• 查看应用日志

• 使用jstack、jmap等工具

22. JVM崩溃处理

• 分析错误日志

• 调整JVM参数

• 检查代码中的内存泄漏

• 升级JVM版本

• 增加监控和告警

23. 循环队列

java

class CircularQueue {
    private int[] data;
    private int head, tail, size;
    
    public CircularQueue(int k) {
        data = new int[k];
        head = tail = -1;
        size = k;
    }
    
    public boolean enQueue(int value) {
        if (isFull()) return false;
        if (isEmpty()) head = 0;
        tail = (tail + 1) % size;
        data[tail] = value;
        return true;
    }
    
    public boolean deQueue() {
        if (isEmpty()) return false;
        if (head == tail) head = tail = -1;
        else head = (head + 1) % size;
        return true;
    }
}

24. 多线程通信

• wait/notify机制

• Lock/Condition

• volatile关键字

• BlockingQueue

• CountDownLatch/CyclicBarrier

25. 多线程有序执行

java

// 使用join()
Thread t1 = new Thread(() -> System.out.println("1"));
Thread t2 = new Thread(() -> {
    try { t1.join(); } catch (InterruptedException e) {}
    System.out.println("2");
});
Thread t3 = new Thread(() -> {
    try { t2.join(); } catch (InterruptedException e) {}
    System.out.println("3");
});

// 使用单线程池
ExecutorService executor = Executors.newSingleThreadExecutor();

26. 栈和队列

栈（Stack）：

• LIFO（后进先出）

• 主要操作：push、pop、peek

队列（Queue）：

• FIFO（先进先出）

• 主要操作：offer、poll、peek

双端队列（Deque）：

• 两端都可以插入和删除