聊到Java算法很多开发者第一反应是“面试造火箭工作拧螺丝”。但我这几年在真实项目里被算法救过好几次一次是线上接口偶发超时最后定位到列表查询里藏着个O(n²)的双重循环一次是权限匹配规则从几十条涨到几万条暴力枚举直接跑不动靠剪枝把耗时从秒级压到了毫秒级。所以这篇Java开发核心算法全解析我不打算给你罗列一堆“八股文”而是按实战路径把必学的算法一个个拆开讲清楚什么时候用它、代码怎么写、坑在哪里。无论你是准备面试、刷蓝桥杯还是接手老项目后想优化性能这篇内容都可以拿来直接参考。1. 先别看代码把Java算法学习路径掰开揉碎1.1 为什么Java开发者最容易卡在“会写但不会用”Java生态里框架太多了Spring Boot、MyBatis、各种中间件把很多底层逻辑都封装好了导致不少人工作两三年后算法知识基本还给老师。平时写业务代码就是CRUD很少有机会去构造复杂数据结构等到面试或性能优化时才发现连个多线程条件下的计数排序都想不明白。我遇到过一个真实的场景某个订单统计功能需要从内存里按多个维度聚合数据。同事写了两层for循环外层几千个订单内层几万个明细下单高峰期直接把CPU拉到100%。其实只要改成分组Map加排序复杂度立刻从O(n*m)降下来。这个例子说明算法不是让你去手写红黑树而是培养一种“计算复杂度意识”数据规模一大就要警惕循环嵌套、警惕无谓的全量遍历。另一个常见误区是只记API不记原理。比如Arrays.sort很多人知道它能排序但不知道它底层对基本类型用的是双轴快排Dual-Pivot QuickSort对对象用的是TimSort。前者不稳定后者稳定。如果你对象排序后需要保持相等元素相对顺序直接用Arrays.sort可能就踩坑了。所以学Java算法不是在学数学题是在学“Java语言绑定下的数据操作方式”。1.2 从零到精通的四阶段地图我不建议一上来就啃《算法导论》也别直接刷LeetCode hard。我自己的经验是分四个阶段推进每个阶段解决一类核心问题。阶段核心能力配套练习/场景一基础语法与集合能用Java写清循环、递归、数组操作冒泡排序、二分查找、数组反转二排序与查找理解主流排序算法的时间/空间复杂度会写二分边界快排、归并、堆排序、二分变体三递归、搜索与剪枝掌握DFS/BFS、回溯、剪枝、动态规划入门蓝桥杯基础题、全排列、背包问题四图论与工程优化会处理图模型、最短路径、匹配问题能分析线上性能A*寻路、匈牙利匹配、TopK、JMH测试这里有一个容易被忽略的事实阶段二和阶段三是面试高频区但真正在生产环境里帮助你的是“复杂度分析”和“剪枝思维”。所以每个阶段都要带着真实场景去问自己这个方法如果数据量翻10倍还扛得住吗如果扛不住算法上还能怎么优化2. 排序算法实战从冒泡到归并每一行代码都要懂2.1 冒泡排序的优化与定位冒泡排序是很多人学会的第一个算法但别因为它简单就跳过。它的核心意义在于让你亲手操作数组下标、交换、循环变量建立起“算法是在操作数据结构”的直觉。先看标准版public static void bubbleSort(int[] arr) { int n arr.length; for (int i 0; i n - 1; i) { for (int j 0; j n - 1 - i; j) { if (arr[j] arr[j 1]) { int tmp arr[j]; arr[j] arr[j 1]; arr[j 1] tmp; } } } }这里最经典的两个优化点标志位剪枝如果某一趟没有发生任何交换说明数组已经有序可以提前结束。缩小内层范围每趟结束后最大的元素已经沉底所以内层循环没有必要再碰到已排序区间。public static void optimizedBubbleSort(int[] arr) { int n arr.length; boolean swapped; for (int i 0; i n - 1; i) { swapped false; for (int j 0; j n - 1 - i; j) { if (arr[j] arr[j 1]) { int tmp arr[j]; arr[j] arr[j 1]; arr[j 1] tmp; swapped true; } } if (!swapped) break; } }实际生产里你几乎不会用冒泡排序处理大数组因为时间复杂度是O(n²)。但它的思维价值在于“相邻比较交换”这衍生出了部分排序场景的简单解法。比如你只需要把最小的三个元素冒泡上来就可以提前终止外层循环得到一个局部有序的前缀。实操心得如果你在业务代码里发现有人写了冒泡数据规模又超过一万别急着骂先用它有没有提前终止来判断数据是否接近有序。很多实际场景的数据本身就是“大体有序”的加了标志位的冒泡有时候跑起来并不慢。2.2 堆排序二叉树思想在数组上的落地堆排序是我个人比较偏爱的一个算法因为它把一棵完全二叉树“藏”在数组里只用下标变换就能模拟父子关系。Java里的PriorityQueue就是堆结构但很多人只会把它当普通队列用不知道它内部是数组实现的小顶堆。堆排序的核心步骤分两步建堆和调整。以升序排序为例需要先构建一个大顶堆然后每次把堆顶最大值和末尾元素交换再对剩余部分做下沉调整。父节点和子节点的下标关系是左孩子2*i 1右孩子2*i 2父节点(i - 1) / 2。记住这三个公式堆相关的一切就都好理解了。public static void heapSort(int[] arr) { int n arr.length; // 建堆从最后一个非叶子节点开始下沉 for (int i n / 2 - 1; i 0; i--) { siftDown(arr, i, n); } // 排序每次把堆顶与当前未排序区间的末尾交换 for (int i n - 1; i 0; i--) { int tmp arr[0]; arr[0] arr[i]; arr[i] tmp; siftDown(arr, 0, i); } } private static void siftDown(int[] arr, int parent, int size) { while (true) { int left parent * 2 1; int right left 1; int maxIndex parent; if (left size arr[left] arr[maxIndex]) { maxIndex left; } if (right size arr[right] arr[maxIndex]) { maxIndex right; } if (maxIndex parent) break; int tmp arr[parent]; arr[parent] arr[maxIndex]; arr[maxIndex] tmp; parent maxIndex; } }这里有个容易写错的地方n / 2 - 1是最后一个非叶子节点下标。如果你记不清也可以用(n - 2) / 2效果一样。建堆是从下往上调整的因为只有子树已经满足堆性质时父节点下沉才是有效的。堆排序的时间复杂度稳定在O(n log n)空间复杂度O(1)但实际运行速度往往不如快速排序原因是堆排序对内存的访问跳跃性强缓存命中率低。不过它有一个特殊优势当内存紧张、不能开额外数组时堆排序是唯一一个兼顾O(n log n)和O(1)空间的排序算法。另外求TopK问题用堆排序的思想非常合适Java里可以直接用PriorityQueue。实操心得生产环境求TopK别自己手写堆调整用PriorityQueue限定容量就好。比如要取最大的10个数维护一个容量为10的小顶堆每来一个新元素如果比堆顶大就先弹出堆顶再插入。这样堆里永远保存当前最大的10个复杂度是O(n log k)k远小于n时会非常快。2.3 归并排序稳定排序和分治的完美结合如果说堆排序是数组结构的高阶玩法那归并排序就是分治思想的最佳代表。它的核心是先拆后合把数组从中间切成两半分别排序再合并两个有序数组。public static void mergeSort(int[] arr, int left, int right) { if (left right) return; int mid left (right - left) / 2; mergeSort(arr, left, mid); mergeSort(arr, mid 1, right); merge(arr, left, mid, right); } private static void merge(int[] arr, int left, int mid, int right) { int[] temp new int[right - left 1]; int i left, j mid 1, k 0; while (i mid j right) { if (arr[i] arr[j]) { temp[k] arr[i]; } else { temp[k] arr[j]; } } while (i mid) temp[k] arr[i]; while (j right) temp[k] arr[j]; System.arraycopy(temp, 0, arr, left, temp.length); }归并排序的稳定性和O(n log n)复杂度让它成为很多语言内置排序的基础。Java的Collections.sort对List对象的排序底层是TimSort核心思想就是归并排序加上了一些小数组直接插入排序的优化。所以你自己写的归并排序在思想上和JDK内置排序是有血缘关系的。归并排序还有一个隐藏技能统计逆序对。如果左半数组里的元素大于右半数组里的元素那么这个左半元素和右半元素之间就形成了一个逆序对。在merge过程中加一个计数器即可。static long inverseCount 0; private static void mergeCount(int[] arr, int left, int mid, int right) { int[] temp new int[right - left 1]; int i left, j mid 1, k 0; while (i mid j right) { if (arr[i] arr[j]) { temp[k] arr[i]; } else { inverseCount (mid - i 1); temp[k] arr[j]; } } while (i mid) temp[k] arr[i]; while (j right) temp[k] arr[j]; System.arraycopy(temp, 0, arr, left, temp.length); }这里的mid - i 1是核心当右半边元素arr[j]小于左半边元素arr[i]时左半边从i到mid的所有元素都大于arr[j]所以逆序对数量要累加这一段长度。如果不理解可以拿[3,1,2]手工走一遍merge过程。归并排序最大的缺点是空间O(n)在内存敏感的嵌入式场景不适用。但它的稳定性和可并行性让它非常适合大数据量的外部排序比如几十G日志文件按时间排序内存装不下就是多路归并的思路。3. 查找算法与搜索剪枝暴力不是贬义词但要会剪3.1 二分查找与Java的查找工具类二分查找是所有查找算法里最应该熟练掌握的因为它的边界情况能考察你对“不变式”的理解。我在面试Java开发时经常让候选人手写二分查找十个人里有六个人会栽在left和right的更新上。先看一个最稳妥的左闭右闭写法public static int binarySearch(int[] nums, int target) { int left 0, right nums.length - 1; while (left right) { int mid left (right - left) / 2; if (nums[mid] target) { return mid; } else if (nums[mid] target) { left mid 1; } else { right mid - 1; } } return -1; }这里有两个细节值得专门说求中点用left (right - left) / 2不要用(left right) / 2。后者在left和right都接近int最大值时会溢出变成负数导致死循环。这是老生常谈但仍然有人犯。循环条件是left right所以每次更新边界时一定要mid 1或mid - 1否则会死循环。Java标准库里的Arrays.binarySearch和Collections.binarySearch返回的是一个“负插入点减一”的值这让你可以一次调用就同时知道元素是否存在以及应该插入的位置。但要注意如果数组中有重复元素binarySearch不保证返回哪一个。需要找第一个或最后一个等于目标值的位置必须自己写边界版本。public static int leftBound(int[] nums, int target) { int left 0, right nums.length; while (left right) { int mid left (right - left) / 2; if (nums[mid] target) { left mid 1; } else { right mid; } } return left; // 左边界下标可能为 nums.length }二分查找不仅能处理有序数组还能处理“答案区间单调”的问题比如“在升序数组里找第一个大于等于目标值的元素”“寻找左右边界”“旋转数组找最小值”这些都是蓝桥杯和LeetCode的高频题。实操心得业务里如果需要对一个有序集合频繁查找先想想是不是可以用TreeMap或者NavigableSet的ceilingEntry、floorEntry方法它内部就是红黑树查找能直接拿到“最近的上界/下界”。这比你自己维护一个数组再做二分要省事得多。3.2 暴力枚举和剪枝算法从蓝桥杯到日常业务很多人一听“暴力枚举”就觉得低级但暴力是所有搜索算法的起点。它的思路很简单把所有可能的状态列出来一个个判断是否满足条件。问题是状态空间一大暴力就会爆炸所以必须配合剪枝。剪枝算法在蓝桥杯题目里几乎无处不在。比如经典的“N皇后”问题要在N×N棋盘上放N个皇后要求任何两个皇后不能在同一行、同一列、同一斜线。最笨的暴力是枚举所有组合但用DFS走一行放一个后立刻剪掉冲突列和斜线复杂度会大幅下降。public static ListListString solveNQueens(int n) { ListListString result new ArrayList(); dfs(n, 0, new int[n], new boolean[n], result); return result; } private static void dfs(int n, int row, int[] columnOfRow, boolean[] usedColumn, ListListString result) { if (row n) { ListString board new ArrayList(); for (int i 0; i n; i) { char[] line new char[n]; Arrays.fill(line, .); line[columnOfRow[i]] Q; board.add(new String(line)); } result.add(board); return; } for (int col 0; col n; col) { if (usedColumn[col]) continue; boolean conflict false; for (int i 0; i row; i) { int diffRow row - i; int diffCol Math.abs(col - columnOfRow[i]); if (diffRow diffCol) { conflict true; break; } } if (conflict) continue; columnOfRow[row] col; usedColumn[col] true; dfs(n, row 1, columnOfRow, usedColumn, result); usedColumn[col] false; } }这里的剪枝策略很典型每行只放一个皇后这个约束直接砍掉了大部分组合再利用usedColumn一维布尔数组快速检查列冲突斜线冲突则是回溯时逐个比对。在真正生产环境里类似的场景是多维条件组合匹配比如给用户推荐一组优惠券可能有“同品类最多用一张”“总金额有上限”“必须包含某种券”等约束暴力枚举所有组合后剪枝比盲目全量计算要高效得多。实操心得剪枝的三个常见维度是“可行性剪枝”当前状态不可能到达最终解、“最优性剪枝”当前代价已经超过已知最优解、“重复状态剪枝”用HashSet或boolean数组记录已访问状态。写回溯时最容易忘的是“状态还原”也就是DFS返回前要把标记位撤销否则后续分支会互相污染。3.3 A*算法与启发式搜索的工程应用A*算法是很多游戏寻路、路径规划和图搜索系统的核心算法。它本质上是“Dijkstra 贪心”每次从优先队列里取出“已走路径代价 预估剩余代价”最小的节点继续扩展。这个预估函数h(n)就是启发式函数用于引导搜索方向避免像Dijkstra那样盲目往四周扩散。A的核心公式是f(n) g(n) h(n)其中g是从起点到当前节点的实际代价h是从当前节点到终点的预估代价。只要h满足“可采纳性”h(n)不超过实际最短距离A就能保证找到最优解。下面是一个网格地图寻路的框架用PriorityQueue实现open listclass Node { int x, y; int g, h, f; Node parent; Node(int x, int y) { this.x x; this.y y; } void updateF() { f g h; } } public static Listint[] aStarFindPath(int[][] grid, int[] start, int[] end) { int rows grid.length, cols grid[0].length; boolean[][] closed new boolean[rows][cols]; PriorityQueueNode open new PriorityQueue(Comparator.comparingInt(n - n.f)); Node s new Node(start[0], start[1]); open.offer(s); while (!open.isEmpty()) { Node current open.poll(); if (current.x end[0] current.y end[1]) { return buildPath(current); } closed[current.x][current.y] true; int[][] dirs {{1,0},{-1,0},{0,1},{0,-1}}; for (int[] d : dirs) { int nx current.x d[0]; int ny current.y d[1]; if (nx 0 || nx rows || ny 0 || ny cols) continue; if (grid[nx][ny] 1 || closed[nx][ny]) continue; Node child new Node(nx, ny); child.g current.g 1; child.h Math.abs(nx - end[0]) Math.abs(ny - end[1]); // 曼哈顿距离 child.updateF(); child.parent current; // 真正的实现还需要检查child是否已在open里且g值更小这里省略 open.offer(child); } } return Collections.emptyList(); }这段代码为了好读省略了“open list中g值更新”的逻辑但已经展示了A*的骨架。实际工程里要注意两点一是用曼哈顿距离作为h时要保证只能上下左右移动如果允许斜向移动曼哈顿距离就不是可采纳的二是PriorityQueue里可能同时存在同一个节点的多条路径记录需要维护一个“当前最小g值”的Map来剪枝。实操心得在很多业务系统中“图搜索”并不一定需要显式建图。比如规则引擎里找一条满足所有依赖的执行路径或三维装箱场景里找可行摆放顺序都可以抽象成A*的变体。核心还是fgh想清楚“g是什么”“h怎么估计”搜索效率就能大幅提升。4. 进阶算法专题图论、动态规划与经典模型4.1 匈牙利算法与二分图匹配匈牙利算法解决的是“二分图最大匹配”问题典型场景是任务分配有N个员工和M个任务每个员工只能做其中几个任务怎么分配能让尽可能多的任务有对应员工这个场景在排班系统、物流配送、资源调度里经常出现。它的核心是“增广路径”从一个未匹配的左侧顶点出发如果经过未匹配边、匹配边、未匹配边……交替走到一个未匹配的右侧顶点那么把这条路径上的匹配关系全部反转匹配数就能加一。反复找增广路径直到找不到为止得到最大匹配。用DFS实现时重点是一个matchR数组记录右侧顶点匹配的左侧顶点以及每次尝试时的visited标记。public static int maxMatch(int n, int m, ListInteger[] adj) { int[] matchR new int[m]; Arrays.fill(matchR, -1); int result 0; for (int u 0; u n; u) { boolean[] visited new boolean[m]; if (dfs(u, adj, visited, matchR)) { result; } } return result; } private static boolean dfs(int u, ListInteger[] adj, boolean[] visited, int[] matchR) { for (int v : adj[u]) { if (visited[v]) continue; visited[v] true; if (matchR[v] -1 || dfs(matchR[v], adj, visited, matchR)) { matchR[v] u; return true; } } return false; }这里有一套非常容易混淆的规则visited必须在每次尝试匹配一个左侧顶点时重置因为不同起点可以重新考虑同一个右侧顶点matchR[v] -1 || dfs(matchR[v], ...)表示如果右侧顶点v暂时没匹配或者它当前匹配的左侧顶点能让出位置就允许重新匹配。实操心得如果业务场景带权重比如每个员工做不同任务的成本不同需要最大权完美匹配那要用KM算法而不是匈牙利算法。匈牙利算法只解决“能不能匹配、匹配数量最多”不考虑质量。另外当左侧顶点很多但右侧顶点很少时可以交换角色主动把枚举量压到较小的那一侧。4.2 动态规划状态设计是核心动态规划在Java算法里的地位不用多说蓝桥杯、LeetCode、面试手撕题处处都有它的影子。很多人觉得DP难其实DP的核心就一句话把一个问题拆成互相重叠的子问题用一个数组/表存下子问题的答案避免重复计算。以最经典的0/1背包问题为例有n个物品每个物品有重量w[i]和价值v[i]背包容量是C问能装下的最大价值。二维DP定义dp[i][j]表示前i个物品在背包容量为j时能获得的最大价值。状态转移是第i个物品要么不装继承dp[i-1][j]要么装dp[i-1][j-w[i]] v[i]前提是j w[i]。public static int knapsack(int[] w, int[] v, int C) { int n w.length; int[] dp new int[C 1]; for (int i 0; i n; i) { for (int j C; j w[i]; j--) { dp[j] Math.max(dp[j], dp[j - w[i]] v[i]); } } return dp[C]; }这里最容易被忽视的是内层循环为什么要倒序。因为一维数组dp[j]更新时依赖的dp[j - w[i]]必须还是上一轮的旧值。如果正序更新dp[j - w[i]]可能已经在本轮被覆盖相当于一个物品被重复放入了多次那就变成“完全背包”了。很多候选人面试时能背出代码但问这一句就露馅。实操心得动态规划团队里同样有“剪枝”的影子——不少DP题目可以先用贪心排除部分状态再结合DP求解。比如背包问题如果物品数量巨大但重量范围很小可以按重量归类反之如果价值范围小可以“价值做容量”来换一个维度的DP。需要灵活吃透“状态设计优先于代码”。4.3 LeetCode和蓝桥杯必刷路线刷题不是目的锻炼解题肌肉记忆才是。我见过太多人每天随机刷题今天做链表、明天做DP、后天做图论结果遇到原题变个条件就懵了。正确做法是按专题攻破每个专题至少刷透10-20题。对于Java方向的开发者我的建议路线是数组与字符串两数之和、三数之和、最长无重复子串、合并区间。链表反转链表、合并两个有序链表、环形链表检测。二叉树前中后序遍历、层序遍历、最近公共祖先、二叉树最大深度。排序与查找颜色分类、前K个高频元素、寻找旋转排序数组最小值。回溯与剪枝全排列、子集、组合总和、N皇后。动态规划爬楼梯、最长递增子序列、0/1背包、编辑距离。蓝桥杯的题目风格和LeetCode略有不同它更偏重“暴力枚举优化剪枝数论模拟”。比如很多填空题其实就是让你枚举所有数再用条件筛一遍。这时候掌握剪枝算法比掌握花哨的模板重要得多。当年我准备蓝桥杯时最大的体会是先写暴力再看哪里重复计算了用缓存或剪枝去掉十道题里有八道能这样AC。实操心得刷题时一定要用纸笔先推例子再写代码。直接上手写很容易在边界条件上浪费时间。每做完一道题在题解里标注“核心套路”比如“看到子数组和就要想到前缀和”“看到拓扑排序就要想到入度数组”。积累二三十个这样的套路面试手撕基本就不慌了。5. 算法在真实项目里的落地技巧与常见问题5.1 从算法到代码复杂度分析与性能测试很多人学会算法后反而不知道怎么用。一个重要原因是缺少“复杂度预算”的概念。拿到一个任务先估数据规模再选算法这是职业选手和写代码“凭感觉”的人最大的区别。举个具体例子你有100万条订单记录要在内存里按金额排序取Top10。如果用O(n²)的排序100万的平方是10的12次方假设每秒执行10的8次方次操作那就是一万秒完全不可接受。如果用PriorityQueue做TopK每批只维护10个元素复杂度是O(n log 10)大约几百万次操作毫秒级就能完成。这就是先算复杂度再写代码的价值。Java里验证算法性能不要简单地在main方法里打时间戳因为JVM预热会影响结果。专业性更强的是JMHJava Microbenchmark Harness。如果你只是临时验证也至少要“先执行几千次让JIT热起来再统计耗时”。# 用JMH跑基准测试的典型pom依赖 # org.openjdk.jmh:jmh-core:1.37 # org.openjdk.jmh:jmh-generator-annprocess:1.37实操心得线上排查算法性能问题时先把数据规模、目标耗时、允许的空间增量这三个数字写下来。比如一个接口允许500ms你有10万条数据那算法复杂度最好控制在O(n log n)上下。如果空间允许缓存、预计算都是合法手段不一定非要换算法。5.2 Java算法题最容易踩的坑我总结了一些Java算法代码中特别容易踩的坑很多是面试全场沉默的原因。整数溢出两个int相加可能溢出使用long或先转long再比较。二分查找的mid要用left (right - left) / 2。比较器返回值溢出return o1.age - o2.age在年龄接近Integer.MAX_VALUE时会溢出导致排序错乱要写Integer.compare(o1.age, o2.age)。数组越界递归里常见。比如归并排序的right可能小于left一定要先判断left right。栈溢出递归深度超过默认JVM栈大小通常1MB左右深度几万层就可能炸。深层递归改为循环或显式栈注意设置-Xss只是临时缓解。把可变对象当Map key如果用HashMap存一个ArrayList做key之后修改了list内容hashCode会变导致后续get不到。要用不可变对象或String做key。提前return导致资源未释放算法代码里常忽略IO资源。如果写了文件或网络流记得用try-with-resources。还有一点很多新手会栽对同一个数组在循环里反复排序。排序是有副作用的如果后续逻辑依赖原始顺序一定要先clone()再排。测试代码里把原始数据打乱、分支、重复值都覆盖一遍比跑通一次有用得多。5.3 工具与调试方法Java算法开发调试最高效的工具就是IDE的Debugger但要会用“条件断点”。比如你想看arr[i] 99时发生了什么直接在断点上设置条件i 99就不用一次次按继续。数组嵌套场景用Arrays.deepToString()打印二维数组比手动写循环强太多。集合类型可以直接输出toString。JShell是Java 9之后内置的REPL工具非常适合快速验证一段算法思路。你写完一个方法直接在JShell里调用不用建整个项目。比如验证二分查找的边界先贴方法再贴测试用例几秒出结果。jshell import java.util.*; int[] arr {1, 3, 5, 7, 9}; // 调用你贴进去的binarySearch方法算法可视化网站比如Visualgo对理解排序过程很有帮助看堆排序和快排的动画比看任何文字都直观。日常调试代码逻辑还可以在关键位置打印current的变量状态但要记得在所有分支测试通过后把这些日志去掉避免线上日志污染。实操心得遇到“运行结果对但答案错误”的算法题先检查三个方向边界值空数组、单元素、全是相同元素、整数溢出、返回值不是预期下标而是“插入点”。这三个方向能覆盖大多数隐藏bug。我个人在实际操作中最深的一点体会是Java算法学习如果不是为了解决具体问题很容易变成“自我感动式刷题”。你可以今天就用一个真实需求来练手——比如把线上某个接口里一段O(n²)的匹配逻辑用剪枝或二分优化掉再对比优化前后的性能数据。这种“从一个痛点出发用一个算法收尾”的经验比刷一百道题都值钱。算法不是面试时才拿出来的表演是你调优时的工具箱。把最基础的排序、查找、剪枝、动态规划吃透Java开发这条路会走得比想象中稳得多。