Java 语言特性(面试系列4)

一、数据结构与算法

1. 常见算法

（1）排序算法

算法	时间复杂度（平均）	空间复杂度	稳定性
冒泡排序	O(n²)	O(1)	稳定
选择排序	O(n²)	O(1)	不稳定
插入排序	O(n²)	O(1)	稳定
快速排序	O(n log n)	O(log n)	不稳定
归并排序	O(n log n)	O(n)	稳定
堆排序	O(n log n)	O(1)	不稳定
桶排序	O(n + k)	O(n + k)	稳定

快速排序核心代码：

public void quickSort(int[] arr, int left, int right) {
    if (left < right) {
        int pivotIndex = partition(arr, left, right);
        quickSort(arr, left, pivotIndex - 1);
        quickSort(arr, pivotIndex + 1, right);
    }
}

private int partition(int[] arr, int left, int right) {
    int pivot = arr[right];
    int i = left - 1;
    for (int j = left; j < right; j++) {
        if (arr[j] <= pivot) {
            i++;
            swap(arr, i, j);
        }
    }
    swap(arr, i + 1, right);
    return i + 1;
}

（2）搜索算法

• 二分查找：适用于有序数组，时间复杂度 O (log n)。

  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;
          if (arr[mid] < target) left = mid + 1;
          else right = mid - 1;
      }
      return -1;
  }

  （3）动态规划

• 核心思想：将复杂问题分解为重叠子问题，通过保存子问题的解避免重复计算。
• 经典问题：
  • 斐波那契数列

    public int fib(int n) {
        if (n <= 1) return n;
        int[] dp = new int[n + 1];
        dp[0] = 0;
        dp[1] = 1;
        for (int i = 2; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }

2. 设计模式

（1）单例模式

• 饿汉式：线程安全，类加载时初始化。

  public class Singleton {
      private static final Singleton INSTANCE = new Singleton();
      private Singleton() {}
      public static Singleton getInstance() {
          return INSTANCE;
      }
  }

  懒汉式（双重检查锁）：线程安全，延迟初始化。

  public class Singleton {
      private static volatile Singleton instance;
      private Singleton() {}
      public static Singleton getInstance() {
          if (instance == null) {
              synchronized (Singleton.class) {
                  if (instance == null) {
                      instance = new Singleton();
                  }
              }
          }
          return instance;
      }
  }

（2）工厂模式

• 简单工厂：根据参数创建对象

  public class ShapeFactory {
      public Shape createShape(String type) {
          if ("circle".equalsIgnoreCase(type)) {
              return new Circle();
          } else if ("rectangle".equalsIgnoreCase(type)) {
              return new Rectangle();
          }
          return null;
      }
  }

二、操作系统

1. 进程 / 线程

特性	进程	线程
定义	程序在操作系统中的一次执行过程	进程内的一个执行单元
资源	拥有独立的内存空间和系统资源	共享进程的资源
调度	操作系统进行资源分配和调度的基本单位	CPU 调度的基本单位
通信	进程间通信（IPC）：管道、消息队列、共享内存	直接共享数据
开销	创建 / 销毁开销大	创建 / 销毁开销小
健壮性	进程间互不影响	一个线程崩溃可能导致整个进程崩溃

2. 内存管理

• 虚拟内存：将物理内存和磁盘空间结合，提供更大的地址空间。
• 分页机制：将虚拟内存和物理内存划分为固定大小的页（Page）。
• 页面置换算法：
  • FIFO：先进先出。
  • LRU（最近最少使用）：选择最近最久未使用的页面置换。
  • LFU（最不经常使用）：选择访问次数最少的页面置换。

 3.IO 模型

• 同步阻塞 IO（BIO）：
  • 应用程序发起 IO 请求后，必须等待 IO 操作完成才继续执行。
  • 示例：传统的 Socket 编程。
• 同步非阻塞 IO（NIO）：
  • 应用程序可以不断轮询 IO 操作状态，不阻塞等待。
  • 示例：Java NIO 中的 Selector。
• 异步 IO（AIO）：
  • 应用程序发起 IO 请求后继续执行，IO 操作完成后系统通知应用程序。
  • 示例：Java 7 的 AsynchronousFileChannel。

三、计算机网络

1. HTTP 协议

• 版本：
  • HTTP/1.1：支持持久连接（keep-alive）、分块传输、请求头压缩。
  • HTTP/2：二进制分帧、多路复用、头部压缩、服务器推送。
  • HTTP/3：基于 QUIC 协议，解决 TCP 队头阻塞问题。
• 请求方法：GET、POST、PUT、DELETE、HEAD、OPTIONS 等。
• 状态码：
  • 1xx：信息性状态码（如 100 Continue）。
  • 2xx：成功状态码（如 200 OK、201 Created）。
  • 3xx：重定向状态码（如 301 Moved Permanently）。
  • 4xx：客户端错误（如 404 Not Found、403 Forbidden）。
  • 5xx：服务器错误（如 500 Internal Server Error）。

2. TCP/IP 三次握手

1. 客户端→服务器：发送 SYN 包，请求建立连接，携带初始序列号 ISN (c)。
2. 服务器→客户端：发送 SYN+ACK 包，确认客户端请求，携带自身初始序列号 ISN (s) 和确认号 ACK=c+1。
3. 客户端→服务器：发送 ACK 包，确认服务器响应，确认号 ACK=s+1。

 

四次挥手：

 

1. 客户端发送 FIN 包，表示请求关闭连接。
2. 服务器发送 ACK 包，确认客户端请求。
3. 服务器发送 FIN 包，表示请求关闭连接。
4. 客户端发送 ACK 包，确认服务器请求。

3. 网络分层模型

OSI 七层模型	TCP/IP 四层模型	典型协议
物理层	网络接口层	Ethernet、WiFi
数据链路层		ARP、MAC
网络层	网络层	IP、ICMP、路由协议
传输层	传输层	TCP、UDP
会话层	应用层	SSH、TLS
表示层		SSL/TLS、JSON/XML
应用层		HTTP、SMTP、DNS、FTP

四、综合应用示例

场景：设计一个高并发的电商系统，分析计算机基础的应用

 

1. 算法优化：

   • 商品搜索：使用倒排索引 + 二分查找加速查询。
   • 推荐系统：基于用户行为的协同过滤，使用动态规划优化路径计算。

2. 操作系统：

   • 多线程处理订单：使用线程池避免频繁创建线程。
   • 内存管理：使用 LRU 缓存热门商品信息。
   • IO 优化：采用 NIO 模型处理大量并发请求。

3. 计算机网络：

   • HTTP/2 协议：提升 API 请求性能。
   • 负载均衡：通过 Nginx 实现 HTTP 请求分发。
   • 数据传输：使用 TCP 保证订单数据可靠传输