Java 8 如何一次性获得数组的索引和最大值？

给定一个整型元素列表，如何一次性获得最大值及其索引。如果有多个元素具有相同的最大值，则可以返回其中任何一个元素的索引

例如：

// Initialize list of integer
List<Integer> intList = Arrays.asList(5, 8, 3, 2);
// To get max value
Optional<Integer> maxVal = intList.stream().reduce(Integer::max);
// But how could I also get its index without iterating the array again?

//初始化整数列表
List intList=Arrays.asList（5,8,3,2）；
//获得最大值
可选的maxVal=intList.stream（）.reduce（整数：：max）；
//但是，我如何在不再次迭代数组的情况下也获得它的索引呢？

---

如果我只需要做一次，我可以对数组进行排序，得到第一个或最后一个（基于排序顺序）。但是，我想看看我们如何在不进行排序的情况下做到这一点。

通常，如果您需要索引，则必须对索引进行流式处理。然后，任务变得简单明了：

List<Integer> intArr = Arrays.asList(5, 8, 3, 2);
IntStream.range(0, intArr.size())
  .reduce((a,b)->intArr.get(a)<intArr.get(b)? b: a)
  .ifPresent(ix->System.out.println("Index "+ix+", value "+intArr.get(ix)));

---

如果您不介意使用第三方代码，“我的库”为此任务提供了一些快捷方式：

List<Integer> intArr = Arrays.asList(5, 8, 3, 2);
IntStreamEx.ofIndices(intArr)
           .maxBy(intArr::get)
           .ifPresent(ix->System.out.println("Index "+ix+", value "+intArr.get(ix)));

List intArr=Arrays.asList（5,8,3,2）；
intstreamx.ofIndices（intArr）
.maxBy（intArr:：get）
.ifPresent（ix->System.out.println（“索引“+ix+”，值“+intar.get（ix）））；

在内部，它接近@Holger提供的第一个解决方案（无装箱）。

在java8中，您可以

Integer[]intar={1,2,6,2234,3,54,64564456}；
IntStream.range（0，intar.length-1）.parallel（）。
reduce（（a，b）->intArr[a]System.out.println（“索引：+ix+”，值：+intArr[ix]）；

我认为目前没有任何解决方案能像手动迭代一样快：

int maxValueIndex = 0;
Integer maxValue = null;
for (int i = 0, n = intList.size(); i < n; ++i) {
    Integer value = intList.get(i);
    if (value == null || maxValue != null && value <= maxValue)
        continue;
    maxValue = value;
    maxValueIndex = i;
}

int-maxValueIndex=0；
整数maxValue=null；
对于（inti=0，n=intList.size（）；i如果（value==null | | maxValue！=null&&value装箱的意义是什么？@SriniK我相信那是因为你不能有一个
比较器
。但是，我可能是错的，因为我对Java 8还是有点陌生。@Chetan Kinger：你是对的，没有
比较器
，因此，
IntStream
不提供
max（Comparator）
方法，但只有一个
max（）
在这里没有帮助（同样适用于
min
或
sorted
，
IntStream
只支持自然顺序）。@Holger为什么不直接使用
intArr.stream（）.max（Comparator）
操作。未指定将处理哪些元素，因为缩减函数需要是关联的，所以它可以执行
（（e1 op e2）op e3）op e4
或
（e1 op e2）op（e3 op e4）
，但您可以看到，在这两种情况下，操作的数量都是相同的。
max
操作只是一种特殊的内置简化，具有完全相同的时间复杂度。
Integer[] intArr= {1,2,6,2,234,3,54,6,4564,456};

IntStream.range(0, intArr.length-1).parallel().
                reduce((a,b)->intArr[a]<intArr[b]? b: a).
                ifPresent(ix -> System.out.println("Index: " + ix + ", value: " + intArr[ix]));

int maxValueIndex = 0;
Integer maxValue = null;
for (int i = 0, n = intList.size(); i < n; ++i) {
    Integer value = intList.get(i);
    if (value == null || maxValue != null && value <= maxValue)
        continue;
    maxValue = value;
    maxValueIndex = i;
}