如何从列表中收集多个最大值

Question

How to get max from an ArrayList that has more than one max? For example, if an ArrrayList contains max = 20 stored at index 2, 3 and 6, how do you get all that indicies?

Answer 1

The obvious way is to first get maximum value by Collections.max() , then collect indicies where items are equal to max:

public <T extends Comparable<? super T>> List<Integer> maxIndicies(List<T> input) {
    if (input.isEmpty())  // avoid exception thrown by Collections.max() if input is empty
        return Collections.emptyList();
    final T max = Collections.max(input);
    return IntStream.range(0, input.size())
               .filter(i -> input.get(i).compareTo(max) == 0)
               .boxed()
               .collect(Collectors.toList()); 
}

Additionally, I'd like to propose another solution where iteration is performed only once. During iteration, you need to check two things for each item: 1) if it is greater than current max , set a new max and reset result list, 2) if it is equal to current max , add its index to result list:

public <T extends Comparable<? super T>> List<Integer> maxIndicies(List<T> input) {
    T max = null;
    List<Integer> res = new ArrayList<>();
    for (int i = 0; i < input.size(); i++) {
       T item = input.get(i);
       if (max == null || item.compareTo(max) > 0) {   // item > max => reset
           res.clear();
           max = item;
           res.add(i);
       } else if (item.compareTo(max) == 0)            // item equals current max
           res.add(i);
    }
    return res;
}

This won't give you value of max item itself, but you can get it by any returned index, simply as:

List<Integer> maxInd = maxIndicies(list);
maxValue = maxInd.isEmpty() ? null : list.get(maxInd.get(0));

Answer 2

Another approach using streams. That solution assumes that you want to know how often the max occurs (not the indices).

public static Map.Entry<Integer, Long> getMaxWithOccurrences(
        List<Integer> list) {
    return list
            .stream()
            .collect(
                    Collectors.groupingBy(i -> i, TreeMap::new,
                            Collectors.counting())).lastEntry();
}

Answer 3

I'd use a simple and easy to read for loop.

public List<Integer> getMaxIndices(List<Integer> values) {
    Integer max = Collections.max(values);

    List<Integer> maxIndices = new ArrayList<>();
    for (int i = 0; i < values.size(); i++) {
        if (values.get(i).equals(max)) {
            maxIndices.add(Integer.valueOf(i));
        }
    }
    return maxIndices;
}

Answer 4

Integer maxValue = Collections.max(list);

int numberofMax = Collections.frequency(list, maxValue);

this "numberofMax" will return how many maximum values the "list" has.

Answer 5

通常的最大值查找器仅存储最大值，在这里，您将必须维护一个与最大值匹配的索引列表。

Answer 6

You can do it in following way:

public void findMaxIndices() {
    //Your list with numbers
    List<Integer> list = new ArrayList<Integer>(Arrays.asList(1,2,3,4,5,6,7,8,9,1,2,3,4,5,6,7,8,9));

    //Sorted Map which will contain key as numbers and value as list of indices where your 'key' exists in the list
    SortedMap<Integer, List<Integer>> indexMapping = new TreeMap<Integer, List<Integer>>();

    for(int i = 0; i< list.size(); i++) {
        //Get the number at index i
        int number = list.get(i);
        //Check if any index corresponding to 'number' as index has been added to your map
        List<Integer> mapping = indexMapping.get(number);
        if(mapping == null) {
            //instantiate the list if no index has been added yet 
            mapping = new ArrayList<Integer>();
            //Key as your 'number'
            indexMapping.put(number, mapping);
        }
        //Add the index of the 'number' to the mapping list, which is mapped by key as 'number'
        mapping.add(i);         
    }
    //Last key in sorted map will be your highest number in the list, get the value corresponding to it. Following prints: [8,17]
    int maxNumber = indexMapping.lastKey(); //Maximum number found
    System.out.println(indexMapping.get(maxNumber)); //Indices where maximum number exists

}

This way, you can also find indices with lowest values easily:

indexMapping.get(indexMapping.firstKey());

Answer 7

This sounds like a homework for your programming course. You should do it yourself but anyway here is the solution.

private List<Integer> getAllMaxIndices(List<Integer> aList) {

    List<Integer> result = new ArrayList<Integer>();

    // check argument
    if (aList == null || aList.isEmpty()) {
        return result;
    }

    // initialize the list with the index of the first element
    result.add(0);

    Integer tmpInt;
    Integer tmpFirstIndexOfMaxInt;
    Integer tmpMaxInt;
    for (int i = 0; i < aList.size(); i++) {

        // save the current integer and the currently maximum integer
        tmpInt = aList.get(i);
        tmpFirstIndexOfMaxInt = result.get(0);
        tmpMaxInt = aList.get(tmpFirstIndexOfMaxInt);

        // if the current element is greater than the last found
        if (tmpInt > tmpMaxInt) {
            // empty the result
            result.clear();

            // start collecting indices again
            result.add(i);
        }
        // if the current element is equal to the last found
        else if (tmpInt.intValue() == tmpMaxInt.intValue()) {
            // insert the current index in the result
            result.add(i);
        }
    }

    return result;
}

I will leave it to you to write the code which tests this function.