如何使用Java查找给定列表中具有重复项的最大数的索引

我有一个值为[1,2,2,8,7,8]的列表。我想找到最大数量的索引。这里最大的数字是8。8重复两次。所以答案应该是[3,5]，即8的索引

我花了很多时间。我能找到最大的数字。我无法找到一个干净简单的解决方案来查找索引

import java.util.ArrayList;
import java.util.List;

public class Test {

    public static void main(String[] args) {
        List<Integer> parts = new ArrayList<>();
        parts.add(1);
        parts.add(2);
        parts.add(2);
        parts.add(8);
        parts.add(7);
        parts.add(8);

        Test ob = new Test();
        System.out.println("Indexs with max value:" + ob.getIndex(parts));
    }

    public List<Integer> getIndex(List<Integer> parts) {
        int big = parts.get(0);
        List<Integer> indexes = new ArrayList<>();
        for (int i = 1; i < parts.size(); i++) {
            if (big <= parts.get(i)) {
                big = parts.get(i);
                indexes.add(i);
            }
        }
        System.out.println("Biggest Number:" + big);
        return indexes;
    }
}

import java.util.ArrayList；
导入java.util.List；
公开课考试{
公共静态void main（字符串[]args）{
列表部件=新的ArrayList（）；
增加第（1）部分；
增加第（2）部分；
增加第（2）部分；
增加第（8）部分；
增加第（7）部分；
增加第（8）部分；
测试ob=新测试（）；
System.out.println（“具有最大值的索引：“+ob.getIndex（parts））；
}
公共列表getIndex（列出部分）{
int big=parts.get（0）；
列表索引=新的ArrayList（）；
对于（int i=1；iif（big你就快到了；当你遇到一个新的“最大”数字时，你只需要清除列表。你可以通过在你的
if
语句中添加如下内容来完成：

        if (big <= parts.get(i)) {

            // new biggest number, so previous indexes no longer apply
            if (big < parts.get(i)) {
                indexes.clear();
            }

            big = parts.get(i);
            indexes.add(i);
        }

如果（big你就快到了，当你发现一个更大的数字时，你只是忘记清理你的列表：

      for (int i = 0; i < parts.size(); i++) {
            if (big <= parts.get(i)) {
                if(big < parts.get(i))
                   indexes.clear();
                big = parts.get(i);
                indexes.add(i);
            }

for（int i=0；i
遇到新的“最大”编号时，重新创建
索引
列表，将该索引添加到新列表中（或清除列表并添加新索引）。如果该编号等于当前的“最大”编号，则将索引添加到列表中

public List<Integer> getIndex(List<Integer> parts) {
    int big = parts.get(0);
    List<Integer> indexes = new ArrayList<>();
    for (int i = 1; i < parts.size(); i++) {
        if (big < parts.get(i)) {
            // new biggest, create new list starting with this index
            big = parts.get(i);
            indexes = new ArrayList<>();
            indexes.add(i);
        } else if (big == parts.get(i)) {
            // new instance, add index
            indexes.add(i);
        } // else do nothing, not bigger or instance of current biggest 
    }
    System.out.println("Biggest Number:" + big);
    return indexes;
}

public List getIndex（列出部分）{
int big=零件。get（0）；
列表索引=新的ArrayList（）；
对于（int i=1；i

结果：

最大数字：8

具有最大值的索引：[3,5]

每次发现值大于大时，都需要清除索引列表
如果是大的和
部分，则需要将索引添加到索引中。获取（i）=big

您需要检查零件是否为空
您需要在循环之前将索引0添加到索引中，因为零件可以只包含一个元素
这是代码：

public List<Integer> getIndex(List<Integer> parts) {
    List<Integer> indexes = new ArrayList<>();
    if (!parts.isEmpty()) {
        int big = parts.get(0);
        indexes.add(0);
        for (int i = 1; i < parts.size(); i++) {
            if (big < parts.get(i)) {
                big = parts.get(i);
                indexes.clear();
                indexes.add(i);
            } else if (big == parts.get(i)) {

                indexes.add(i);
            }
        }
    }
    return indexes;
}

可以使用一个排序映射来解析它，该映射包含输入列表的键元素和索引列表的值

TreeMap valueindex=newtreemap（）；

索引列表可以通过不同的方式创建/填充：


使用
:

List List=Arrays.asList（1,2,2,8,7,8）；
对于（int i=0；inew ArrayList（））；
增加（i）；
}
System.out.println（“valueIndexes:+valueIndexes.lastEntry（）.getValue（））；//对于空输入列表，lastEntry可能为null


Map:：merge
不太方便，因为创建了许多中间列表：

for（int i=0；i{l1.addAll（l2）；返回l1；}//合并函数
);
}
System.out.println（“合并valueIndexes:+valueIndexes.lastEntry（）.getValue（））；


类似地，可以从使用
Collectors.groupingBy+Collectors.mapping创建的未排序映射中选择最大元素，然后选择最大键和相关索引列表：

List maxindex=IntStream.range（0，List.size（））
.boxed（）
.collect（收集器.groupingBy（i->list.get（i）），
Collectors.mapping（i->i，Collectors.toList（））//构建索引列表
))
.entrySet（）
.stream（）
.collect（Collectors.maxBy（Map.Entry.comparingByKey（）））
.orElse（Map.entry（-1，Collections.emptyList（））.getValue（）；
System.out.println（maxIndexes）；

可以结合这些方法从收集器检索的已排序映射中获取最后一个条目：

List maxIndexes2=IntStream.range（0，List.size（））
.boxed（）
.collect（收集器）.groupingBy（i->list.get（i），TreeMap:：new，
Collectors.mapping（i->i，Collectors.toList（））
))
.lastEntry（）.getValue（）；
System.out.println（maxindexs2）；
您可以循环两次。1.查找最大的数字2.查找此最大数字的索引。
public List<Integer> getIndex(List<Integer> parts) {
    List<Integer> indexes = new ArrayList<>();
    if (!parts.isEmpty()) {
        int big = parts.get(0);
        indexes.add(0);
        for (int i = 1; i < parts.size(); i++) {
            if (big < parts.get(i)) {
                big = parts.get(i);
                indexes.clear();
                indexes.add(i);
            } else if (big == parts.get(i)) {

                indexes.add(i);
            }
        }
    }
    return indexes;
}

Indexs with max value:[3, 5]