以下是10个Java面试常见手写代码题的实现，涵盖单例模式、排序算法、线程池等核心知识点：
单例模式（双重校验锁）
public class Singleton { private volatile static Singleton instance; private Singleton() {} public static Singleton getInstance() { if (instance == null) { synchronized (Singleton.class) { if (instance == null) { instance = new Singleton(); } } } return instance; } }快速排序
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; } private void swap(int[] arr, int i, int j) { int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; }线程池实现
public class CustomThreadPool { private final BlockingQueue<Runnable> taskQueue; private final List<WorkerThread> workers; public CustomThreadPool(int poolSize) { this.taskQueue = new LinkedBlockingQueue<>(); this.workers = new ArrayList<>(); for (int i = 0; i < poolSize; i++) { WorkerThread worker = new WorkerThread(); worker.start(); workers.add(worker); } } public void execute(Runnable task) { taskQueue.offer(task); } private class WorkerThread extends Thread { public void run() { while (true) { try { Runnable task = taskQueue.take(); task.run(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } } } }生产者消费者模式
public class ProducerConsumer { private final Queue<Integer> queue = new LinkedList<>(); private final int capacity; public ProducerConsumer(int capacity) { this.capacity = capacity; } public void produce() throws InterruptedException { int value = 0; while (true) { synchronized (this) { while (queue.size() == capacity) { wait(); } queue.add(value++); notifyAll(); Thread.sleep(1000); } } } public void consume() throws InterruptedException { while (true) { synchronized (this) { while (queue.isEmpty()) { wait(); } int value = queue.poll(); notifyAll(); Thread.sleep(1000); } } } }二分查找
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; }反转链表
public ListNode reverseList(ListNode head) { ListNode prev = null; ListNode curr = head; while (curr != null) { ListNode nextTemp = curr.next; curr.next = prev; prev = curr; curr = nextTemp; } return prev; }LRU缓存实现
class LRUCache { class Node { int key, value; Node prev, next; Node(int key, int value) { this.key = key; this.value = value; } } private Map<Integer, Node> cache; private int capacity; private Node head, tail; public LRUCache(int capacity) { this.capacity = capacity; cache = new HashMap<>(); head = new Node(0, 0); tail = new Node(0, 0); head.next = tail; tail.prev = head; } public int get(int key) { if (!cache.containsKey(key)) return -1; Node node = cache.get(key); remove(node); add(node); return node.value; } public void put(int key, int value) { if (cache.containsKey(key)) { remove(cache.get(key)); } Node node = new Node(key, value); cache.put(key, node); add(node); if (cache.size() > capacity) { Node toRemove = tail.prev; remove(toRemove); cache.remove(toRemove.key); } } private void add(Node node) { Node next = head.next; head.next = node; node.prev = head; node.next = next; next.prev = node; } private void remove(Node node) { Node prev = node.prev; Node next = node.next; prev.next = next; next.prev = prev; } }二叉树层序遍历
public List<List<Integer>> levelOrder(TreeNode root) { List<List<Integer>> result = new ArrayList<>(); if (root == null) return result; Queue<TreeNode> queue = new LinkedList<>(); queue.offer(root); while (!queue.isEmpty()) { int levelSize = queue.size(); List<Integer> currentLevel = new ArrayList<>(); for (int i = 0; i < levelSize; i++) { TreeNode node = queue.poll(); currentLevel.add(node.val); if (node.left != null) queue.offer(node.left); if (node.right != null) queue.offer(node.right); } result.add(currentLevel); } return result; }字符串转整数（atoi）
public int myAtoi(String s) { if (s == null || s.isEmpty()) return 0; int index = 0, sign = 1, total = 0; // 跳过空格 while (index < s.length() && s.charAt(index) == ' ') { index++; } // 处理符号 if (index < s.length() && (s.charAt(index) == '+' || s.charAt(index) == '-')) { sign = s.charAt(index) == '+' ? 1 : -1; index++; } // 转换数字 while (index < s.length()) { int digit = s.charAt(index) - '0'; if (digit < 0 || digit > 9) break; // 检查溢出 if (Integer.MAX_VALUE / 10 < total || (Integer.MAX_VALUE / 10 == total && Integer.MAX_VALUE % 10 < digit)) { return sign == 1 ? Integer.MAX_VALUE : Integer.MIN_VALUE; } total = 10 * total + digit; index++; } return total * sign; }实现阻塞队列
public class BlockingQueue<T> { private Queue<T> queue = new LinkedList<>(); private int capacity; private Lock lock = new ReentrantLock(); private Condition notFull = lock.newCondition(); private Condition notEmpty = lock.newCondition(); public BlockingQueue(int capacity) { this.capacity = capacity; } public void put(T element) throws InterruptedException { lock.lock(); try { while (queue.size() == capacity) { notFull.await(); } queue.add(element); notEmpty.signal(); } finally { lock.unlock(); } } public T take() throws InterruptedException { lock.lock(); try { while (queue.isEmpty()) { notEmpty.await(); } T item = queue.remove(); notFull.signal(); return item; } finally { lock.unlock(); } } }（支持资料、图片参考_相关定制）)
