编写查找int中最频繁数字的Java方法

在这个问题上我需要帮助：

编写一个方法mostFrequentDigit，返回数字中最常出现的数字值。示例：数字669260267包含：一个0、两个2、四个6、一个7和一个9。 mostFrequentDigit（669260267）返回6。 如果出现平局，返回数值较低的数字。 mostFrequentDigit（57135203）返回3

这是我现在拥有的代码，但它不起作用：

public static int mostFrequentDigit(int num)
{
int largestCount = 0;
int currentCount = 0;
String num0 = Integer.toString(num)
 String mostFrequent = num0.substring(0,1);

for (int x = 0; x < num0.length(); x++)
{
        if (num0.substring(x,x+1).equals(mostFrequent))
        {
            currentCount++;
        }
        if (currentCount > largestCount)
        {
           largestCount = currentCount;
           mostFrequent = num0.substring(x,x+1);
        }
}
    return mostFrequent;

}

公共静态int-mostFrequentDigit（int-num）
{
int最大计数=0；
int currentCount=0；
字符串num0=Integer.toString（num）
字符串mostFrequent=num0.子字符串（0,1）；
对于（int x=0；x最大计数）
{
最大计数=当前计数；
mostFrequent=num0.子串（x，x+1）；
}
}
返回最频繁；
}

您必须跟踪所有数字的计数（例如，在数组中或

映射中），并在对所有数字进行计数后获得结果

下面是一种使用数组的方法：

public class MyClass {
    public static int mostFrequentDigit(int num) {
        int n = Math.abs(num);
        int digit = 0;
        int max = 0;
        int[] counts = new int[10];

        while (n != 0) {
            counts[n % 10]++;
            n /= 10;
        }

        for (int i = 0; i < counts.length; i++) {
            if (counts[i] > max) {
                digit = i;
                max = counts[i];
            }
        }

        return digit;
    }
    
    public static void main(String args[]) {
      System.out.println(mostFrequentDigit(57135203));
    }
}

公共类MyClass{
公共静态int-mostFrequentDigit（int-num）{
int n=Math.abs（num）；
整数位数=0；
int max=0；
int[]计数=新的int[10]；
而（n！=0）{
计数[n%10]+；
n/=10；
}
for（int i=0；i最大值）{
数字=i；
最大值=计数[i]；
}
}
返回数字；
}
公共静态void main（字符串参数[]）{
System.out.println（MOSTFrequentDigital（57135203））；
}
}

此代码段使用模和整数除法操作的组合来获取单独的数字，并为每个数字增加数组中相应的计数器。计算完所有数据后，它将遍历数组以查找计数器最高的数字。
代码中存在一些逻辑错误。
提供一个简单而简短的代码，如下所示

import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;

import org.apache.commons.lang3.StringUtils;

        public static int mostFrequentDigit(int num) {

        Map<String, Integer> map = new HashMap<String, Integer>();

        for (int i = 0; i < 10; i++) {
            String digit = String.valueOf(i);
            map.put(digit, StringUtils.countMatches(String.valueOf(num), digit));
        }

        Comparator<Map.Entry<String, Integer>> byValue = Map.Entry.comparingByValue();
        Map.Entry<String, Integer> maxEntry = Collections.max(map.entrySet(), byValue);

        return Integer.parseInt(maxEntry.getKey());
    }

import java.util.Collections；
导入java.util.Comparator；
导入java.util.HashMap；
导入java.util.Map；
导入org.apache.commons.lang3.StringUtils；
公共静态int-mostFrequentDigit（int-num）{
Map Map=newhashmap（）；
对于（int i=0；i<10；i++）{
字符串数字=字符串。值（i）；
put（digit，StringUtils.countMatches（String.valueOf（num），digit））；
}
Comparator byValue=Map.Entry.comparingByValue（）；
Map.Entry maxEntry=Collections.max（Map.entrySet（），byValue）；
返回Integer.parseInt（maxEntry.getKey（））；
}
似乎是学校作业的问题。你的老师肯定希望你学习递归

因此，将数据收集到大小为10的数组中（如果您计算的是基数10，那么您可以对基数16执行相同的操作）

编写递归函数（根据需要调用自身的函数）
它取一个数的最后一位（十进制数为模10），并将该数的其余部分（除以10，但作为整数）传递给它自己的下一次调用（如果大于0）

递归终止后，您将得到一个带有数字计数的数组。
只需使用for循环处理它，然后找到具有最大值的索引，您可以通过java8方法执行以下操作：

public static int mostFrequentDigit(int num){
    Map<String, Long> collect = Integer.toString(num).chars().mapToObj(c -> (char) c).map(String::valueOf)
            .collect(groupingBy(Function.identity(), counting()));
    long maxCount = collect.values().stream().reduce(Math::max).orElse(0L);
    return collect.entrySet().stream().filter(a -> a.getValue() == maxCount)
            .map(a -> Integer.parseInt(a.getKey())).reduce(Math::min).orElse(null);
}

公共静态int-mostFrequentDigit（int-num）{
Map collect=Integer.toString（num）.chars（）.mapToObj（c->（char）c）.Map（String:：valueOf）
.collect（groupby（Function.identity（），counting（））；
long maxCount=collect.values（）.stream（）.reduce（数学：：max）.orElse（0L）；
return collect.entrySet（）.stream（）.filter（a->a.getValue（）==maxCount）
.map（a->Integer.parseInt（a.getKey（））.reduce（Math:：min）.orElse（null）；
}
这是否满足“如果出现平局，返回数值较低的数字”条件？此外，如果使用外部库，最好指定从何处获取该库。当然，这满足“如果存在平局，则返回值较低的数字”条件。感谢提醒您指定可从何处获取该库。包java.util可以从中获得，它是java语言中常用的库。当然，这满足了“如果有平局，返回值较低的数字”的条件。我不知道怎么做。这张地图杂乱无章。您的
maxEntry
将只包含上次遇到的具有最高值的条目。我不是说
java.util
包。这是JDK的一部分。我说的是您正在使用的Apache Commons库。要更新org.Apache.Commons.lang3可以在这里找到感谢回复更新org.Apache.Commons.lang3可以在这里找到Collections.max将找到最频繁的数字和较低的值（不是最后遇到的）将对负数抛出异常。@Robby问题中没有负数，请仔细阅读问题。提供的两个示例中没有负数，但问题说明：“编写一个方法mostFrequentDigit，返回数字中最常出现的数字值。”它没有说正数。顺便说一句，如果可能有任何负值，你可以使用
Integer.toString（Math.abs（num））
而不是
Integer.toString（num）
。嗨！非常感谢你的帮助。你能为我澄清一下你在while循环中做了什么吗？目的是什么？你为什么要做n%10，为什么不只是n？谢谢<代码>n%10

将为您提供号码的最后一位数字。比方说，这个数字是

3

。然后

计数[n%10]++

转换为

计数[3]++

，这意味着数组中第四个元素的值将递增。在while-loo的末尾