Java手写argmax工具类：从基础实现到泛型与性能优化

1. 为什么需要自己动手实现argmax

1.1 从一次数据清洗的踩坑说起

去年帮一个做推荐系统的朋友处理一批用户行为日志，需要从每行浮点数组里找出最大值所在的索引。当时第一反应是用循环遍历，写了个十来行的方法，跑起来也没问题。但后来数据量从几万条涨到几百万条，那段代码成了整个流水线的瓶颈——每次都要手动比较、手动记录索引，代码又长又容易在边界条件上翻车。

后来我翻了下项目里其他人写的工具类，发现类似“找最大值索引”的逻辑散落在五六个地方，每个版本的边界处理都不一样：有的遇到空数组直接抛异常，有的返回-1，有的返回0。这种不一致在联调阶段特别折磨人。于是我就想，干脆写一个通用的argmax工具方法，把这件事一次性做对。

argmax这个概念本身不复杂——给定一组数值，返回最大值对应的下标。它在机器学习、统计分析、信号处理里出现频率极高。比如分类模型输出一个概率数组，你要取概率最大的那个类别；比如音频处理里找峰值位置；比如金融数据里定位某段时间的最高价出现在第几天。这些场景的共同点就是：你要的不是最大值本身，而是它在序列中的位置。

Java标准库里有Collections.max()能拿最大值，有Arrays.sort()能排序，但就是没有一个现成的“返回最大值索引”的方法。这就是为什么很多人选择自己写一个。这篇文章就把我实际项目中反复打磨过的几个版本整理出来，从最朴素的循环到支持泛型和自定义比较器的通用方案，附带完整源码和踩坑记录。

1.2 这篇文章适合谁看

如果你写过Java，知道数组和List的基本操作，那这篇内容你就能直接上手。我会从最简单的int数组版本开始，逐步扩展到double、泛型、多维数组，最后给一个可以直接扔进工具类的完整实现。每一版都会解释为什么这么写、什么场景下用哪一版、以及我实际踩过的坑。

如果你正在做机器学习相关的Java开发，或者需要处理大量数值计算，那argmax这个工具方法几乎一定会用到。与其每次临时写一个，不如花二十分钟看完这篇，把代码复制过去改改就能用。

2. argmax的核心逻辑与设计考量

2.1 一句话说清argmax在做什么

用最直白的话讲：给你一排数字，你从头到尾看一遍，记住最大的那个数出现在第几个位置，最后把这个位置告诉我。就这么简单。

但“简单”不等于“没有坑”。我见过太多实现栽在下面这几个问题上：

• 数组为空怎么办？抛异常还是返回-1？
• 有多个相同的最大值时，返回第一个还是最后一个？
• 数组里全是负数呢？初始值设成0就完蛋了。
• 浮点数比较能用==吗？NaN怎么处理？
• 传入的数组是null呢？

这些问题在业务代码里不处理好，轻则逻辑错误，重则线上事故。我印象特别深的一次是，某同学写的argmax把初始最大值设成了0，结果一批全负数的数据跑出来索引全是0，排查了一下午才发现问题。所以下面每一版实现，我都会把这些边界情况考虑进去。

2.2 返回值设计：int索引还是包装类型

先定一个基调：argmax的返回值用int还是Integer？

我的选择是用int，空数组时抛异常。理由有三条：

第一，argmax的语义是“最大值的位置”，如果数组为空，这个位置根本不存在，返回任何特殊值（-1、0、Integer.MIN_VALUE）都是在掩盖问题。调用方拿到-1之后还得判断，不如直接抛IllegalArgumentException，让问题在源头暴露。

第二，用int可以避免拆箱装箱的开销。在百万级数据的循环里，每次返回都装箱成Integer，累积起来对GC是有压力的。

第三，如果确实有“可能为空”的场景，调用方自己包一层判空逻辑更清晰，而不是让argmax承担这个模糊职责。

当然，如果你的业务场景里空数组是常态，那可以额外提供一个返回OptionalInt的重载版本，这个后面会讲。

2.3 多个最大值时的策略选择

假设数组是[3, 1, 5, 5, 2]，最大值5出现了两次，索引分别是2和3。argmax应该返回哪个？

数学上argmax的定义通常返回第一个最大值的位置。这个约定在大多数场景下是合理的：你希望结果稳定、可预测，同样的输入永远得到同样的输出。

但也有场景需要返回最后一个，比如你想知道某个峰值最后出现的位置。所以我的做法是：默认返回第一个，同时提供一个boolean参数控制是否返回最后一个。这样既保持了默认行为的直观性，又给了灵活性。

实现上很简单，比较的时候用>就是第一个，用>=就是最后一个。但要注意，如果用>=，每次相等都要更新索引，在数据有很多重复最大值时会有额外的赋值开销，虽然可以忽略不计，但知道这个细节有助于理解代码行为。

3. 从零实现：基础版本与逐步演进

3.1 最简版本：int数组的argmax

先上最核心的代码，这是所有后续版本的基础：

public static int argmax(int[] array) { if (array == null || array.length == 0) { throw new IllegalArgumentException("数组不能为空"); } int maxIndex = 0; int maxValue = array[0]; for (int i = 1; i < array.length; i++) { if (array[i] > maxValue) { maxValue = array[i]; maxIndex = i; } } return maxIndex; }

这段代码有几个细节值得说：

初始值设为array[0]而不是0或Integer.MIN_VALUE。设成0的话，全负数数组就废了；设成Integer.MIN_VALUE虽然能处理负数，但如果数组第一个元素就是Integer.MIN_VALUE，逻辑上也没问题，但多了一次不必要的比较。直接用第一个元素初始化，既安全又少一次循环。

循环从i=1开始。因为第0个元素已经作为初始值了，没必要再和自己比一次。

用>而不是>=。这保证了返回的是第一个最大值的索引。如果你想要最后一个，改成>=即可。

这个版本的时间复杂度是O(n)，空间复杂度O(1)，对于绝大多数场景已经够用了。我实测过，在一台普通开发机上，处理一千万个int的数组，耗时大约在5到8毫秒之间，完全能满足常规业务需求。

3.2 支持double数组：浮点数的坑

double版本的argmax不能简单地把int换成double，因为浮点数比较有特殊性。先看代码：

public static int argmax(double[] array) { if (array == null || array.length == 0) { throw new IllegalArgumentException("数组不能为空"); } int maxIndex = 0; double maxValue = array[0]; for (int i = 1; i < array.length; i++) { if (Double.isNaN(array[i])) { continue; } if (array[i] > maxValue || Double.isNaN(maxValue)) { maxValue = array[i]; maxIndex = i; } } return maxIndex; }

这里处理了两个浮点数特有的问题：

NaN的处理。NaN和任何值比较都返回false，包括它自己。如果数组里有NaN，用普通的>比较会导致NaN被跳过，但如果整个数组都是NaN，maxValue会一直是初始的NaN，maxIndex始终为0。我的策略是：跳过NaN，不让它参与比较。如果所有元素都是NaN，那就返回0，因为没有任何有效值可以比较。

初始值为NaN的情况。如果array[0]是NaN，那么第一次比较时array[i] > maxValue永远是false，所以需要额外判断Double.isNaN(maxValue)，一旦发现当前最大值是NaN，就用第一个非NaN元素替换它。

注意：如果你的业务场景里NaN有特殊含义（比如表示缺失值），那应该在调用argmax之前就把NaN处理掉，而不是依赖argmax内部的跳过逻辑。工具方法应该保持行为可预测，业务逻辑的决策留给调用方。

3.3 泛型版本：支持任意可比较类型

当你的数据不是基本类型，而是Integer、Double、String或者自定义对象时，就需要泛型版本了：

public static <T extends Comparable<? super T>> int argmax(T[] array) { if (array == null || array.length == 0) { throw new IllegalArgumentException("数组不能为空"); } int maxIndex = 0; T maxValue = array[0]; for (int i = 1; i < array.length; i++) { if (array[i] == null) { continue; } if (maxValue == null || array[i].compareTo(maxValue) > 0) { maxValue = array[i]; maxIndex = i; } } return maxIndex; }

泛型版本的关键点在于Comparable<? super T>这个边界。用? super T而不是T extends Comparable<T>，是为了让子类也能比较。比如Integer实现了Comparable<Integer>，但如果你有一个MyNumber extends Integer，用? super T就能让MyNumber数组也能用这个argmax。

null值的处理策略和NaN类似：跳过null，如果全是null就返回0。这里同样要注意，如果array[0]是null，maxValue初始为null，第一次比较时需要特殊处理。

对于List版本，逻辑几乎一样，只是把数组下标换成list.get(i)：

public static <T extends Comparable<? super T>> int argmax(List<T> list) { if (list == null || list.isEmpty()) { throw new IllegalArgumentException("列表不能为空"); } int maxIndex = 0; T maxValue = list.get(0); for (int i = 1; i < list.size(); i++) { T current = list.get(i); if (current == null) { continue; } if (maxValue == null || current.compareTo(maxValue) > 0) { maxValue = current; maxIndex = i; } } return maxIndex; }

3.4 自定义比较器：应对复杂排序规则

有时候“最大”的定义不是自然顺序。比如你有一个Person类，想找出年龄最大的人，但Person本身没有实现Comparable。这时候就需要传入一个Comparator：

public static <T> int argmax(T[] array, Comparator<? super T> comparator) { if (array == null || array.length == 0) { throw new IllegalArgumentException("数组不能为空"); } if (comparator == null) { throw new IllegalArgumentException("比较器不能为空"); } int maxIndex = 0; T maxValue = array[0]; for (int i = 1; i < array.length; i++) { if (array[i] == null) { continue; } if (maxValue == null || comparator.compare(array[i], maxValue) > 0) { maxValue = array[i]; maxIndex = i; } } return maxIndex; }

这个版本把比较逻辑完全交给调用方，灵活性最高。你可以按年龄比、按姓名比、按综合评分比，甚至写一个反向比较器来找最小值。

实操心得：Comparator的compare方法返回值语义是“负数表示第一个小，正数表示第一个大，0表示相等”。写自定义比较器时最容易犯的错是把正负号搞反，建议写完先拿几组边界数据测一下，比如相等的情况、第一个比第二个大的情况。

4. 多维数组与批量处理的进阶方案

4.1 二维数组的argmax：按行还是按列

二维数组的argmax有两种常见需求：一是对每一行分别求argmax，返回一个索引数组；二是对整个二维数组求全局argmax，返回行号和列号。

先看按行处理的版本：

public static int[] argmaxRows(double[][] matrix) { if (matrix == null || matrix.length == 0) { throw new IllegalArgumentException("矩阵不能为空"); } int[] result = new int[matrix.length]; for (int i = 0; i < matrix.length; i++) { result[i] = argmax(matrix[i]); } return result; }

这个实现直接复用了前面的一维argmax，代码简洁，逻辑清晰。每一行独立处理，互不影响。如果某一行是空的，argmax会抛异常，这符合“快速失败”的原则。

全局argmax稍微复杂一点，需要同时记录行号和列号：

public static int[] argmaxGlobal(double[][] matrix) { if (matrix == null || matrix.length == 0) { throw new IllegalArgumentException("矩阵不能为空"); } int maxRow = 0; int maxCol = 0; double maxValue = Double.NEGATIVE_INFINITY; boolean found = false; for (int i = 0; i < matrix.length; i++) { if (matrix[i] == null) { continue; } for (int j = 0; j < matrix[i].length; j++) { double val = matrix[i][j]; if (Double.isNaN(val)) { continue; } if (!found || val > maxValue) { maxValue = val; maxRow = i; maxCol = j; found = true; } } } if (!found) { throw new IllegalArgumentException("矩阵中没有有效数值"); } return new int[]{maxRow, maxCol}; }

这里用了一个found标志位来处理“所有元素都是NaN或矩阵全空”的情况。初始的maxValue设为负无穷，但因为有found标志，第一次遇到有效值时一定会更新。

4.2 批量处理：一次调用处理多个数组

在实际项目中，我经常遇到需要同时对一批数组求argmax的场景。比如一个batch里有128个样本，每个样本是一个长度为10的概率分布，需要一次性拿到128个索引。这时候如果循环调用一维argmax，每次都有方法调用的开销。虽然JIT会做内联优化，但写一个批量版本更直观：

public static int[] argmaxBatch(double[][] batch) { if (batch == null || batch.length == 0) { throw new IllegalArgumentException("批次不能为空"); } int[] result = new int[batch.length]; for (int b = 0; b < batch.length; b++) { double[] row = batch[b]; if (row == null || row.length == 0) { result[b] = -1; continue; } int maxIdx = 0; double maxVal = row[0]; for (int i = 1; i < row.length; i++) { if (Double.isNaN(row[i])) { continue; } if (row[i] > maxVal || Double.isNaN(maxVal)) { maxVal = row[i]; maxIdx = i; } } result[b] = maxIdx; } return result; }

这个版本对空行返回-1而不是抛异常，因为在批量处理中，个别样本异常不应该中断整个批次。这是批处理场景和单次调用场景的一个重要区别。

4.3 性能对比：不同实现的耗时实测

为了给读者一个直观的参考，我在本地做了一组简单的性能测试。测试环境是JDK 17，处理器是常见的开发本配置，数据规模为1000万个随机double值，每种实现跑10次取平均值：

结论很清晰：基础for循环最快，泛型版本因为装箱和虚方法调用慢了约3倍，Stream API最慢。并行Stream在数据量大时能追回来一些，但线程调度本身也有开销，数据量小的时候反而更慢。

所以我的建议是：对性能敏感的热点路径，用基本类型专用版本；一般业务代码，泛型版本的可读性和灵活性更值得；Stream API适合那种“写起来爽、跑起来不差这点时间”的场景。

5. 常见问题与排查技巧实录

5.1 空数组和null的边界处理速查

边界条件是argmax最容易出问题的地方。我把常见的输入情况和推荐处理方式整理成了一张表：

这张表是我在多个项目中总结出来的，基本上覆盖了95%以上的边界场景。如果你拿不准某种情况该怎么处理，可以对照这张表做决定。

5.2 浮点数比较的精度陷阱

浮点数比较有一个经典陷阱：0.1 + 0.2 != 0.3。在argmax里，这个问题表现为：两个理论上相等的值，因为浮点误差可能一个比另一个大一点点，导致argmax返回了“错误”的索引。

比如数组是[0.1+0.2, 0.3]，理论上两个值相等，argmax应该返回0。但实际上0.1+0.2等于0.30000000000000004，比0.3大，所以返回0——这次碰巧对了。但如果顺序反过来[0.3, 0.1+0.2]，就会返回1，而你可能期望返回0。

解决这个问题有两种思路：

第一种是引入一个epsilon阈值，当两个值的差小于epsilon时视为相等：

private static final double EPSILON = 1e-9; if (array[i] > maxValue + EPSILON) { // 更新 }

第二种是在调用argmax之前，先把数据做一次舍入处理，比如保留6位小数。具体用哪种取决于你的业务对精度的要求。

注意：epsilon的选取没有万能值。1e-9适合大多数场景，但如果你的数据本身量级很大（比如1e15），这个epsilon就太小了；如果数据量级很小（比如1e-15），这个epsilon又太大了。建议根据实际数据的量级来调整。

5.3 并发场景下的线程安全问题

argmax本身是一个无状态的纯函数，不修改输入数组，也不依赖任何共享变量，所以天然是线程安全的。你可以放心地在多线程环境里并发调用同一个argmax方法。

但有一个例外：如果你传入的数组在argmax执行期间被其他线程修改了，那结果就不确定了。这不是argmax的问题，而是调用方需要保证的——要么传入不可变数据，要么在调用期间加锁。

我在实际项目中遇到过一种情况：多个线程共享一个可变的double数组，一个线程在写，另一个线程在调argmax。结果偶尔会拿到一个“中间状态”的索引。后来改成每个线程持有自己的数据副本，问题就消失了。所以记住一句话：argmax线程安全，但你的数据不一定。

5.4 常见问题速查表

这张表里的每一条都是我或同事实际踩过的坑。特别是第一条“返回的索引总是0”，在新手代码里出现频率极高，原因就是习惯性地把初始最大值设成了0。

6. 完整工具类源码与使用示例

6.1 可直接复用的ArgmaxUtils

把前面所有版本整合到一个工具类里，方便直接复制到项目中使用：

import java.util.Comparator; import java.util.List; public final class ArgmaxUtils { private ArgmaxUtils() { } public static int argmax(int[] array) { if (array == null || array.length == 0) { throw new IllegalArgumentException("数组不能为空"); } int maxIndex = 0; int maxValue = array[0]; for (int i = 1; i < array.length; i++) { if (array[i] > maxValue) { maxValue = array[i]; maxIndex = i; } } return maxIndex; } public static int argmax(double[] array) { if (array == null || array.length == 0) { throw new IllegalArgumentException("数组不能为空"); } int maxIndex = 0; double maxValue = array[0]; for (int i = 1; i < array.length; i++) { if (Double.isNaN(array[i])) { continue; } if (array[i] > maxValue || Double.isNaN(maxValue)) { maxValue = array[i]; maxIndex = i; } } return maxIndex; } public static <T extends Comparable<? super T>> int argmax(T[] array) { if (array == null || array.length == 0) { throw new IllegalArgumentException("数组不能为空"); } int maxIndex = 0; T maxValue = array[0]; for (int i = 1; i < array.length; i++) { if (array[i] == null) { continue; } if (maxValue == null || array[i].compareTo(maxValue) > 0) { maxValue = array[i]; maxIndex = i; } } return maxIndex; } public static <T> int argmax(T[] array, Comparator<? super T> comparator) { if (array == null || array.length == 0) { throw new IllegalArgumentException("数组不能为空"); } if (comparator == null) { throw new IllegalArgumentException("比较器不能为空"); } int maxIndex = 0; T maxValue = array[0]; for (int i = 1; i < array.length; i++) { if (array[i] == null) { continue; } if (maxValue == null || comparator.compare(array[i], maxValue) > 0) { maxValue = array[i]; maxIndex = i; } } return maxIndex; } public static <T extends Comparable<? super T>> int argmax(List<T> list) { if (list == null || list.isEmpty()) { throw new IllegalArgumentException("列表不能为空"); } int maxIndex = 0; T maxValue = list.get(0); for (int i = 1; i < list.size(); i++) { T current = list.get(i); if (current == null) { continue; } if (maxValue == null || current.compareTo(maxValue) > 0) { maxValue = current; maxIndex = i; } } return maxIndex; } public static int[] argmaxRows(double[][] matrix) { if (matrix == null || matrix.length == 0) { throw new IllegalArgumentException("矩阵不能为空"); } int[] result = new int[matrix.length]; for (int i = 0; i < matrix.length; i++) { result[i] = argmax(matrix[i]); } return result; } public static int[] argmaxGlobal(double[][] matrix) { if (matrix == null || matrix.length == 0) { throw new IllegalArgumentException("矩阵不能为空"); } int maxRow = 0; int maxCol = 0; double maxValue = Double.NEGATIVE_INFINITY; boolean found = false; for (int i = 0; i < matrix.length; i++) { if (matrix[i] == null) { continue; } for (int j = 0; j < matrix[i].length; j++) { double val = matrix[i][j]; if (Double.isNaN(val)) { continue; } if (!found || val > maxValue) { maxValue = val; maxRow = i; maxCol = j; found = true; } } } if (!found) { throw new IllegalArgumentException("矩阵中没有有效数值"); } return new int[]{maxRow, maxCol}; } }

这个类设计成final且构造函数私有，符合工具类的标准写法。所有方法都是static，不需要实例化。

6.2 实际调用示例

下面用几个例子展示怎么用这个工具类：

public class ArgmaxDemo { public static void main(String[] args) { int[] scores = {85, 92, 78, 92, 88}; int topIndex = ArgmaxUtils.argmax(scores); System.out.println("最高分索引: " + topIndex); System.out.println("最高分: " + scores[topIndex]); double[] probabilities = {0.1, 0.05, 0.7, 0.1, 0.05}; int predictedClass = ArgmaxUtils.argmax(probabilities); System.out.println("预测类别: " + predictedClass); String[] names = {"Alice", "Charlie", "Bob"}; int maxNameIndex = ArgmaxUtils.argmax(names); System.out.println("字典序最大的名字索引: " + maxNameIndex); double[][] batch = { {0.2, 0.5, 0.3}, {0.8, 0.1, 0.1}, {0.3, 0.3, 0.4} }; int[] batchResult = ArgmaxUtils.argmaxRows(batch); System.out.println("每行最大值索引: " + java.util.Arrays.toString(batchResult)); int[] globalPos = ArgmaxUtils.argmaxGlobal(batch); System.out.println("全局最大值位置: 行" + globalPos[0] + " 列" + globalPos[1]); } }

运行这段代码，输出会是：

最高分索引: 1 最高分: 92 预测类别: 2 字典序最大的名字索引: 1 每行最大值索引: [1, 0, 2] 全局最大值位置: 行1 列0

注意names数组的argmax返回1，因为"Charlie"在字典序上大于"Alice"和"Bob"。这个例子说明泛型版本可以处理任何实现了Comparable的类型。

6.3 在机器学习场景中的典型用法

如果你在做Java端的模型推理，argmax几乎是后处理的标准步骤。假设模型输出一个logits数组，你需要拿到预测类别：

double[] logits = model.forward(input); int predictedClass = ArgmaxUtils.argmax(logits);

如果是批量推理，输出是一个二维数组，每行是一个样本的logits：

double[][] batchLogits = model.forwardBatch(batchInput); int[] predictedClasses = ArgmaxUtils.argmaxRows(batchLogits);

这里有一个实操细节：有些模型的输出可能包含NaN（比如数值溢出导致），这时候argmax的NaN跳过逻辑就派上用场了。但更好的做法是在模型输出层加一个数值稳定处理，比如减去最大值再算softmax，从源头避免NaN。

实操心得：在模型推理场景中，argmax通常和softmax配合使用。但如果你只关心预测类别而不关心概率值，其实可以跳过softmax直接对logits做argmax，因为softmax是单调递增函数，不改变最大值的位置。这样能省一次指数运算，在批量推理时累积起来很可观。

7. 扩展思路与性能优化建议

7.1 用并行流加速大规模数据

当数组长度达到千万级别，单线程的for循环可能需要几十毫秒。如果这个argmax在关键路径上被频繁调用，可以考虑用并行流：

public static int argmaxParallel(double[] array) { if (array == null || array.length == 0) { throw new IllegalArgumentException("数组不能为空"); } return java.util.stream.IntStream.range(0, array.length) .parallel() .filter(i -> !Double.isNaN(array[i])) .boxed() .max(java.util.Comparator.comparingDouble(i -> array[i])) .orElseThrow(() -> new IllegalArgumentException("没有有效数值")); }

但要注意，并行流有线程池管理和任务拆分的开销。我实测下来，数组长度低于100万时，并行流反而比单线程慢。只有当数据量足够大（比如500万以上）且机器有多核时，并行流才有明显优势。

另外，并行流返回的是第一个最大值还是最后一个最大值是不确定的，因为并行任务的合并顺序不固定。如果你的业务对“第一个最大值”有严格要求，就不要用并行流。

7.2 用SIMD思想做分块处理

对于极致性能场景，可以把数组分成若干块，每块独立求argmax，最后合并结果。这种分块思想虽然Java没有直接的SIMD指令支持，但通过循环展开和局部变量缓存，也能获得一定的性能提升：

public static int argmaxBlocked(double[] array) { if (array == null || array.length == 0) { throw new IllegalArgumentException("数组不能为空"); } final int BLOCK = 8; int maxIndex = 0; double maxValue = array[0]; int i = 1; int len = array.length; for (; i + BLOCK <= len; i += BLOCK) { for (int j = 0; j < BLOCK; j++) { int idx = i + j; if (array[idx] > maxValue) { maxValue = array[idx]; maxIndex = idx; } } } for (; i < len; i++) { if (array[i] > maxValue) { maxValue = array[i]; maxIndex = i; } } return maxIndex; }

这种写法的思路是让CPU的分支预测器更容易预测循环模式，同时减少循环变量的更新次数。实际测试中，对于1000万长度的数组，分块版本比朴素版本快大约10%到15%。提升不算巨大，但在高频调用的场景下值得考虑。

7.3 后续可以怎么扩展

这个工具类还有几个可以继续扩展的方向：

一是支持float、long、short等更多基本类型。虽然可以通过泛型统一处理，但基本类型专用版本能避免装箱开销。

二是增加argmin方法，逻辑和argmax完全对称，只是比较方向反过来。实际项目中argmin的需求也很常见，比如找最小损失、最早时间点等。

三是增加topK方法，返回最大的K个值的索引。这个在推荐系统里很常用，比如从候选集中选出得分最高的10个物品。实现上可以用一个大小为K的最小堆来维护当前topK。

四是增加对OptionalInt返回值的支持，给那些不想处理异常的调用方一个更优雅的选择。

这些扩展都不复杂，核心逻辑和argmax一脉相承。把argmax写扎实了，其他都是举一反三的事。

我在实际项目里用这套工具类已经跑了两年多，从最简单的日志分析到模型推理后处理，基本没再为“找最大值索引”这件事写过重复代码。唯一一次改动是给一个特殊场景加了epsilon参数，其他时候都是直接调用。这种一次写好、到处复用的感觉，比每次临时写循环要踏实得多。