在浮点数组和整数数组中查找max元素索引的java通用方法

Question

这基本上是为了避免冗余代码。我有两个不同的数组，一个是Float类型，另一个是Integer类型。我需要在两个数组中找到最大元素的索引，这很容易，因为我可以编写两种不同的方法，一种用于比较浮点，另一种用于比较整数

我试图改进的是只编写一个通用方法，它可以接受数组中的任何一个作为参数，并可以返回最大索引。到目前为止，我尝试过但没有成功的是：

private static int findMaxIndex(Object [] arr){
        int maxIndex =(int) IntStream.range(0,arr.length)
                  .boxed()
                  .max(Comparator.comparingInt(i -> arr[i])) // getting compiler error here
                  .map(max->arr[max])
                  .orElse(-1);
        
        
        return maxIndex;
    }

我希望这样调用此方法：

Float [] a = {0.3f, 0.5f, 0.9f, 0.7f, 0.1f};
Integer []b = {3000, 250, 100, 2000, 2000, 10246};

int maxIndexFloatArray = findMaxIndex(a);
int maxIndexIntegerArray = findMaxIndex(b);

我很确定有更简单的方法可以做到这一点，但我现在对java代码有点生疏了。希望这能正确地解释这个问题

Answer 1

你可以用老式的方式：

private <T> int findMaxIndex(T[] arr, Comparator<T> comparator){
        int maxIndex= 0;
        T currMax = arr[0];
        for (int i=1;i<arr.length;i++){
            if (comparator.compare(currMax,arr[i])<0){
                currMax = arr[i];
                maxIndex = i;
            }
        }
        return maxIndex;
    }

然后像这样称呼它：

private int getMaxFloatIndex(Float[] floatArr){
        return findMaxIndex(floatArr,Float::compareTo);
    }

Answer 2

lambda与reduce比较Comparables

private static <T extends Comparable<? super T>> int findMaxIndex(T[] arr) {
  return IntStream.range(0, arr.length)
      .reduce((l, r) -> arr[l].compareTo(arr[r]) < 0 ? r : l).orElse(-1);
}

对于多个最大值，返回第一个最大值的索引
如果需要最后一个最大值的索引，请将<更改为<=
arr可以为空，但不能包含null值

Answer 3

这一个应该做到：

private static <T extends Number & Comparable<T>> int findMaxIndex(T[] array) {
    if (array == null || array.length == 0) return -1;
    int largest = 0;
    for (int i = 1; i < array.length; i++) {
        if (array[i].compareTo(array[largest]) > 0) largest = i;
    }
    return largest;
}

---

您可以直接告诉编译器，您的泛型参数T应该是同一类型的Number和Comparable

Answer 4

 <T extends Number & Comparable<T>> int findMaxIndex(T[] arr)

这可以找到基于数字的最大值索引、所有数值类型的接口、包装类和原子包装

也可以制作findMax。如果没有数字方面，只需比较就足够了，比如字符串[]

Answer 5

抓住继承层次结构“从上”，我建议Comparable<X>作为findMaxIndex的输入类型。它是最通用的对象类型，您可以区分其中的“max元素”：

private static <X extends Comparable<X>> int findMaxIndex(final X[] arr) {
    return IntStream.range(0, arr.length)
           .boxed()
           .max(
             (Integer idx1, Integer idx2) -> arr[idx1].compareTo(arr[idx2])
           )
           .orElse(-1);
}

为简单起见：希望/假设arr既不为null也不包含null元素！；）（否则：NPE！）

。。。要像这样使用它：

Float[] a = { 0.3f, 0.5f, 0.9f, 0.7f, 0.1f };
Integer[] b = { 3000, 250, 100, 2000, 2000, 10246 };
System.out.println(findMaxIndex(a));
System.out.println(findMaxIndex(b));

印刷品：

---

2
5