Java 如何找到包含空元素的整数数组的最大元素的索引？

我有一个

ArrayList

说：

List<Integer> intlist= Arrays.asList(11,34,500,null,81, null);

List intlist=Arrays.asList（11,34500，null，81，null）；

---

我想得到最大值的索引。但我有空元素。如何操作？

您可以检查

null

元素以忽略循环中的元素：

public static void main(String[] args) {
    System.out.println(getIndexOfMax(Arrays.asList(11,34,500,null,81, null))); //2
    System.out.println(getIndexOfMax(Arrays.asList(null,null,null,200))); //3
    System.out.println(getIndexOfMax(Arrays.asList(null,null,null))); //-1
}
private static int getIndexOfMax(List<Integer> list) {
    int indexOfMax = -1;
    int max = Integer.MIN_VALUE;
    for(int i = 0; i < list.size(); i++) {
        Integer num = list.get(i);
        if(num != null && num > max) {
            indexOfMax = i;
            max = num;
        }
    }
    return indexOfMax;
}

publicstaticvoidmain（字符串[]args）{
System.out.println（getIndexOfMax（Arrays.asList（11,34500，null，81，null））；//2
System.out.println（getIndexOfMax（Arrays.asList（null，null，null，200））；//3
System.out.println（getIndexOfMax（Arrays.asList（null，null，null））；/-1
}
私有静态int getIndexOfMax（列表）{
int indexOfMax=-1；
int max=整数的最小值；
对于（int i=0；imax）{
indexOfMax=i；
max=num；
}
}
返回指数最大值；
}

对不起，我把问题看错了。我建议创建一个方法，如果没有找到max，则返回-1

List<Integer> intlist= Arrays.asList(11,34,500,null,81, null);
int index = getIndexForMax(intlist);
if (index >= 0) {
     System.out.println(intlist.get(index));
}

方法

public static int getIndexForMax(List<Integer> list) {
   int indx = -1; // default index
   int max = Integer.MIN_VALUE; // smallest possible value
   for (int i = 0; i < list.size(); i++) {
      if (list.get(i) != null) {
        int cv = list.get(i); 
          if (cv > max) {
            max = cv;  // save max
            indx = i; // and its index
          }
      }
   }
   return indx;
}
    

公共静态int-getIndexForMax（列表）{
int indx=-1；//默认索引
int max=Integer.MIN_VALUE；//可能的最小值
对于（int i=0；i最大值）{
max=cv；//保存max
indx=i；//及其索引
}
}
}
返回indx；
}

您可以使用

流

过滤掉空值，并找到最大值。如果找到最大值，您可以使用

indexOf

方法在列表中查找此项的索引

代码

List<Integer> intlist = Arrays.asList(11, 34, 500, null, 81, null);

int maxindex = intlist.stream()
            .filter(Objects::nonNull)
            .max(Integer::compare)
            .map(intlist::indexOf)
            .orElse(-1);

System.out.println(maxindex);

不使用的索引查找最大值+的备选方案 还可以避免使用

indexOf

，通过使用

reduce

方法比较所有元素并保留最大元素，直接获得最大索引。在这里，我们创建一个流来生成所有可能的索引，并使用这些索引来检查值是否不为null。在该检查之后，我们减少流以仅保留最大值的索引

int maxindex = IntStream.range(0, intlist.size())
            .filter(i -> intlist.get(i) != null)
            .reduce((i, j) -> intlist.get(i) > intlist.get(j) ? i : j)
            .orElse(-1);

System.out.println(maxindex);

您可以使用查找最大值，通过该值可以获取其索引。确保传递

Objects:：nonNull

以丢弃

null

元素

import java.util.Arrays;
import java.util.List;
import java.util.Objects;

public class Main {
    public static void main(String[] args) {
        List<Integer> intList = Arrays.asList(11, 34, 500, null, 81, null);
        int idxMax = intList.indexOf(intList.stream()
                                            .filter(Objects::nonNull)
                                            .max(Integer::compare)
                                            .orElse(-1) // You can put here any value just to avoid NoSuchElementException 
                                                        // in case intList is empty. For empty intList, intlist.indexOf(that_value)
                                                        // will return -1 because that_value doesn't exist in the empty intList
                                    );
        System.out.println(idxMax);
    }
}

或者

List<Integer> intList = Arrays.asList(11, 34, 500, null, 81, null);
int idxMax = intList.indexOf(intList.stream()
                                    .filter(Objects::nonNull)
                                    .reduce(Integer::max)
                                    .orElse(-1)
                            );
System.out.println(idxMax);

List intList=Arrays.asList（11,34500,null,81,null）；
int idxMax=intList.indexOf（intList.stream（）
.filter（对象：：非空）
.reduce（整数：：最大值）
.orElse（-1）
);
System.out.println（idxMax）；

尝试下面的代码

public static Integer max(List<Integer> intList) {
    if (intList == null || intList.isEmpty()) {
        throw new IllegalArgumentException("Number list must not empty !");
    }
    Integer max = intList.get(0);
    for (int i = 1; i < intList.size(); i++) {
        if (max != null && intList.get(i) != null && max < intList.get(i)) {
            max = intList.get(i);
        }
    }
    return max;
}

public静态整数最大值（List intList）{
if（intList==null | | intList.isEmpty（））{
抛出新的IllegalArgumentException（“数字列表不能为空！”）；
}
整数max=intList.get（0）；
对于（inti=1；i

谢谢，但是如何获得max元素的原始索引？我误解了这个问题，基本上你需要做的是迭代列表项，在每次迭代中检查

num

是否不是

null

并且大于

max

（在开始时设置为第一个索引），将最后一个更新为

i

。当输入列表为（null，null，null，200）时失败@i更新了答案以处理此情况谢谢，但是如何获取max元素的原始索引？

2

List<Integer> intList = Arrays.asList(11, 34, 500, null, 81, null);
int idxMax = intList.indexOf(intList.stream()
                                    .filter(Objects::nonNull)
                                    .reduce(Integer::max)
                                    .orElse(-1)
                            );
System.out.println(idxMax);

public static Integer max(List<Integer> intList) {
    if (intList == null || intList.isEmpty()) {
        throw new IllegalArgumentException("Number list must not empty !");
    }
    Integer max = intList.get(0);
    for (int i = 1; i < intList.size(); i++) {
        if (max != null && intList.get(i) != null && max < intList.get(i)) {
            max = intList.get(i);
        }
    }
    return max;
}