Question

所以这是我到目前为止的代码......

import java.util.Scanner;
class count{
    public static void main(String args[]){
        Scanner s=new Scanner(System.in);
        System.out.println("Enter a string");
        String sent=s.nextLine();
        int len = sent.length();
        int arr[]=new int[len];
        int count=1;
        char ch[] = new char[len];
        for(int i = 0; i <= len-1; i ++)
        {
            ch[i] = sent.charAt(i);

        }
        for(int j= 0;j<=len-1;j++){
            for(int k=0;k<=len-1;k++){
                if(ch[j]==ch[k]){
                    arr[j]= count++;
                }
            }
        }

        int max=arr[0];
        for(int z=1;z<=len-1;z++){
            if(count>max)
                max=count;
        }
        System.out.println(max);
        System.out.println("The character that appears the most number of times is "  +arr[max]);
    }
}

我计算显示每个字符出现在字符串中的次数，我无法将其与数组中其余元素进行比较。

出现次数存储在数组'arr []'中如何找到此数组中的最大整数？另外，如何显示出现次数最多的字符？

代码的逻辑无效，

  int max=arr[0];

关于该做什么的任何想法？

Answer 1

使用Collections。简单易行。
使用HashMap <Character,Integer>。
解析您已阅读的String。对于字符串中的每个字符，检查它是否在地图中可用（作为键）。如果是，则递增计数，否则将字符作为键添加到地图中，并将计数设置为0.
sort the map

Answer 2

    String sent = "asdAdFfaedfawghke4";//s.nextLine();      
    int length = sent.length();
    char frequentChar = ' ';
    int maxLength = 0;
    for (int i = 0; i < length; i++) {
        char currentChar = sent.charAt(0);
        sent = sent.replaceAll(currentChar + "", "");//remove all charactes from sent
        if (maxLength < (length - sent.length())) {
            frequentChar=currentChar;
            maxLength = length - sent.length();
        }
        System.out.println("Char : " + currentChar + " Occurance " + (length - sent.length()));
        length = sent.length();
    }
    System.out.println("Max Occurance : " + maxLength);

输出：

Char : a Occurance 3
Char : s Occurance 1
Char : d Occurance 3
Char : A Occurance 1
Char : F Occurance 1
Char : f Occurance 2
Char : e Occurance 2
Frequent Char : a
Max Occurance : 3

Answer 3

使用Int =使用Char出现在输入字符串中的次数构建HashMap;在O（n）中，其中n =输入字符串的长度。
在O（m）中查找HashMap中的最大值，其中m是输入字符串中唯一字符的数量。
总的来说，复杂度是O（n），因为n> m。

提示：在构建HashMap的同时，可以存储最大值和相应的字符。仍然是O（n），但代码会更清晰。

Answer 4

首先初始化arr [] 即

for(int i=0;i<len-1;i++{
arr[i]=0;
}

然后：

for(int j= 0;j<=len-1;j++){
  count=0;
  for(int k=0;k<=len-1;k++){
      if(ch[j]==ch[k]){
          arr[j]= count++;
    }
  }
}

Answer 5

您可以使用以下逻辑来获取最大出现的char。下面的程序将整个字符串转换为大写，然后它将计算最大出现的字符，它将在upperCase中打印字符。

import java.util.Scanner;
class Mostchar{
public static void main(String args[]){
Scanner s=new Scanner(System.in);
System.out.println("Enter a string");
String sent=s.nextLine();
sent = sent.toUpperCase();
System.out.println(sent);
int len = sent.length();
int arr[]=new int[26];
int max=0;
char ch=0;
for(int i=0;i<len;i++)
{
    arr[sent.charAt(i)-65] = arr[sent.charAt(i)-65] + 1;
    if(arr[sent.charAt(i)-65]>max)
    {
        max = arr[sent.charAt(i)-65];
        ch=sent.charAt(i);
    }
}
System.out.println("Max occured char is: "+ch+" , times: "+max);


}
}

Answer 6

我会做这样的事情

    String str = "yabbadabbadoo";
    Hashtable<Integer, Integer> ht = new Hashtable<Integer, Integer>() ;
    for (int x = 0; x < str.length(); x++) {
        Integer idx = (int) str.charAt(x);
        Integer got = ht.get(idx);
        if (got == null) {
            ht.put(idx, 1);
        } else {
            ht.put(idx, got.intValue() + 1);
        }
    }

    int max = 0;
    char ch = '-';
    Enumeration<Integer> keys = ht.keys();
    while (keys.hasMoreElements()) {
        Integer idx = keys.nextElement();
        int count = ht.get(idx);
        if (count > max) {
            ch = (char) idx.intValue();
            max = count;
        }
    }

    System.out.print("[" + ch + "]");
    System.out.println(" Max " + max);

请记住大写和小写字符

Answer 7

变量count需要在每次k次迭代后重置值，所以它看起来像这样

    for(int j= 0;j<=len-1;j++){
        for(int k=0;k<=len-1;k++){
            if(ch[j]==ch[k]){
                arr[j]= count++;
            }
        }count=1;
    }

此外，当您尝试在数组中找到最大值时，这将更容易和更正。

    int max=0;
    for(int z=1;z<=len-1;z++){
        if(arr[z]>arr[max])
            max=z;
    }

你正在做什么（而不是它已经重置的计数）是存储第一个字符的出现次数，然后将其与否进行比较。最后一个字符的出现次数，以及是否多于最后一次出现的字符。

Answer 8

假设您有这个例子：

<强> BACAVXARB

然后你的第一个阵列ch的输出将是：

ch[0]=B
ch[1]=A
ch[2]=C
ch[3]=A
ch[4]=V
ch[5]=X
ch[6]=A
ch[7]=R
ch[8]=B

然后下一个输出是：

arr[0]=2
arr[1]=3
arr[2]=1
arr[3]=3
arr[4]=1
arr[5]=1
arr[6]=3
arr[7]=1
arr[8]=2

但是输出会是错误的，因为计数器，永远不会重置，所以我们这样做：

for(int j= 0;j<=len-1;j++){
    for(int k=0;k<=len-1;k++){
        if(ch[j]==ch[k]){
            arr[j]= count++;
        }
    }
    count=1;
}

然后，你的最大变量是：

max=2

所以，在这里我们有一个问题在你的最后一个，我做了这个，使用我自己的变量：

int newCounter;
for(i=0; i<= len-1; i++){
    if(arr[i]>max){
        max = arr[i];
        newCounter = i; //We create this new variable, to save the position, so we will always have the same counter on arr[i] and ch[i]
    }
}

所有缺失的部分是：

System.out.println("The character that repeats the most is: " + ch[newCounter]);

输出应该是：重复次数最多的字符是：A

希望这有帮助

Java程序找到在String中出现次数最多的字符？

8 个答案: