如何使用Java在字符串中找到最常出现的字符？

How to find the most frequently occurring character in a string with Java?

提问by IT_Philic

Given a paragraph as input, find the most frequently occurring character. Note that the case of the character does not matter. If more than one character has the same maximum occurring frequency, return all of them I was trying this question but I ended up with nothing. Following is the code that I tried but it has many errors I am unable to correct:

给定一个段落作为输入，找出最常出现的字符。请注意，字符的大小写无关紧要。如果不止一个字符具有相同的最大出现频率，则返回所有字符我正在尝试这个问题，但最终什么也没得到。以下是我尝试过的代码，但它有很多我无法纠正的错误：

public class MaximumOccuringChar {

    static String testcase1 = "Hello! Are you all fine? What are u doing today? Hey Guyz,Listen! I have a plan for today.";

    public static void main(String[] args) 
    {
        MaximumOccuringChar test = new MaximumOccuringChar();
        char[] result = test.maximumOccuringChar(testcase1);
        System.out.println(result);
    }

    public char[] maximumOccuringChar(String str) 
    {
        int temp = 0;
        int count = 0;
        int current = 0;

        char[] maxchar = new char[str.length()];

        for (int i = 0; i < str.length(); i++) 
        {
            char ch = str.charAt(i);

            for (int j = i + 1; j < str.length(); j++) 
            {
                char ch1 = str.charAt(j);

                if (ch != ch1) 
                {
                    count++;
                }
            }

            if (count > temp) 
            {
                temp = count;
                maxchar[current] = ch;
                current++;
            }
        }
        return maxchar;
    }
}

采纳答案by Anton Eremenko

You already got your answer here: https://stackoverflow.com/a/21749133/1661864

您已经在这里得到了答案：https: //stackoverflow.com/a/21749133/1661864

It's a most easy way I can imagine.

这是我能想象到的最简单的方法。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class MaximumOccurringChar {

    static final String TEST_CASE_1 = "Hello! Are you all fine? What are u doing today? Hey Guyz,Listen! I have a plan for today. Help!";


    public static void main(String[] args) {
        MaximumOccurringChar test = new MaximumOccurringChar();
        List<Character> result = test.maximumOccurringChars(TEST_CASE_1, true);
        System.out.println(result);
    }


    public List<Character> maximumOccurringChars(String str) {
        return maximumOccurringChars(str, false);
    }

    // set skipSpaces true if you want to skip spaces
    public List<Character> maximumOccurringChars(String str, Boolean skipSpaces) {
        Map<Character, Integer> map = new HashMap<>();
        List<Character> occurrences = new ArrayList<>();
        int maxOccurring = 0;

        // creates map of all characters
        for (int i = 0; i < str.length(); i++) {
            char ch = str.charAt(i);

            if (skipSpaces && ch == ' ')      // skips spaces if needed
                continue;

            if (map.containsKey(ch)) {
                map.put(ch, map.get(ch) + 1);
            } else {
                map.put(ch, 1);
            }

            if (map.get(ch) > maxOccurring) {
                maxOccurring = map.get(ch);         // saves max occurring
            }
        }

        // finds all characters with maxOccurring and adds it to occurrences List
        for (Map.Entry<Character, Integer> entry : map.entrySet()) {
            if (entry.getValue() == maxOccurring) {
                occurrences.add(entry.getKey());
            }
        }

        return occurrences;
    }
}

回答by mangusta

Why don't you simply use N letter buckets (N=number of letters in alphabet) ? Just go along the string and increment the corresponding letter bucket. Time complexity O(n), space complexity O(N)

为什么不简单地使用 N 个字母桶（N=字母表中的字母数）？只需沿着字符串并增加相应的字母桶。时间复杂度 O(n)，空间复杂度 O(N)

回答by Danyal

import java.util.Scanner;

public class MaximumOccurringChar{

static String testcase1 = "Hello! Are you all fine? What are u doing today? Hey Guyz,Listen! I have a plan for today.";

public static void main(String[] args) {
    MaximumOccurringChar test = new MaximumOccurringChar();
   String result = test.maximumOccuringChar(testcase1);
    System.out.println(result);
}

public String maximumOccuringChar(String str) {
    int temp = 0;
    int count = 0;
    int current = 0;
    int ind = 0;
    char[] arrayChar = {'a','b' , 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
    int[] numChar = new int[26];
    char ch;
    String s="";
    str = str.toLowerCase();
    for (int i = 0; i < 26; i++) {
        count = 0;
        for (int j = 0; j < str.length(); j++) {
            ch = str.charAt(j);
            if (arrayChar[i] == ch) {
                count++;
            }
        }
        numChar[i] = count++;
    }
    temp = numChar[0];

    for (int i = 1; i < numChar.length; i++) {
        if (temp < numChar[i]) {
            temp = numChar[i];

            ind = i;
            break;
        }
    }
       System.out.println(numChar.toString());
        for(int c=0;c<26;c++)
        {
            if(numChar[c]==temp)
            s+=arrayChar[c]+" ";


        }


    return s;

   }
   }

回答by Jay Sharma

Algorithm:-

算法：-

1. Copying the String character by character to LinkedHashMap.

   • If its a new character then insert new character , 1.
   • If character is already present in the LinkedHashMap then update the value by incrementing by 1.

2. Iterating over the entry one by one and storing it in a Entry object.

   • If value of key stored in entry object is greater than or equal to current entry then do nothing
   • Else, store new entry in the Entry object

3. After looping through, simply print the key and value from Entry object.

1. 将字符串逐字符复制到 LinkedHashMap。

   • 如果它是一个新字符，则插入新字符，1。
   • 如果 LinkedHashMap 中已经存在字符，则通过增加 1 来更新值。

2. 一一迭代条目并将其存储在 Entry 对象中。

   • 如果存储在条目对象中的键值大于或等于当前条目，则什么都不做
   • 否则，在 Entry 对象中存储新条目

3. 循环后，只需打印 Entry 对象中的键和值。

public class Characterop {

公共类 Characterop {

public void maxOccur(String ip)
{

    LinkedHashMap<Character, Integer> hash = new LinkedHashMap();
    for(int i = 0; i<ip.length();i++)
    {
        char ch = ip.charAt(i);
        if(hash.containsKey(ch))
        {
            hash.put(ch, (hash.get(ch)+1));

        }
        else
        {
            hash.put(ch, 1);
        }
    }

   //Set set = hash.entrySet();
   Entry<Character, Integer> maxEntry = null;
   for(Entry<Character,Integer> entry : hash.entrySet())
   {
      if(maxEntry == null)
      {
          maxEntry = entry;
      }

      else if(maxEntry.getValue() < entry.getValue())
      {
          maxEntry = entry;
      }
   }
    System.out.println(maxEntry.getKey());


}
public static void main(String[] args) {
    Characterop op = new Characterop();
    op.maxOccur("AABBBCCCCDDDDDDDDDD");
}

}

}

回答by Sujeet

The Big O below solution is just o(n). Please share your opinion on it.

下面的解决方案的大 O 只是 o(n)。请分享您对此的看法。

    public class MaxOccuringCahrsInStr {

        /**
         * @param args
         */
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            String str = "This is Sarthak Gupta";

            printMaxOccuringChars(str);

        }

        static void printMaxOccuringChars(String str) {
            char[] arr = str.toCharArray();
            /* Assuming all characters are ascii */
            int[] arr1 = new int[256];
            int maxoccuring = 0;

            for (int i = 0; i < arr.length; i++) {
                if (arr[i] != ' ') { // ignoring space
                    int val = (int) arr[i];
                    arr1[val]++;
                    if (arr1[val] > maxoccuring) {
                        maxoccuring = arr1[val];
                    }
                }

            }

            for (int k = 0; k < arr1.length; k++) {
                if (maxoccuring == arr1[k]) {
                    char c = (char) k;
                    System.out.print(c + " ");

                }

            }

        }

    }

回答by RASHID HAMID

function countString(ss)
        {
            var maxChar='';
            var maxCount=0;
            for(var i=0;i<ss.length;i++)
            {
                var charCount=0;
                var localChar=''
                for(var j=i+1;j<ss.length;j++)
                {
                    if(ss[i]!=' ' && ss[i] !=maxChar)
                    if(ss[i]==ss[j])
                    {
                        localChar=ss[i];
                        ++charCount;
                    }
                }
                if(charCount>maxCount)
                {
                    maxCount=charCount;
                    maxChar=localChar;
                }
            }
            alert(maxCount+""+maxChar)
        }

回答by Swetha Kogatam

Another way to solve it. A simpler one.

另一种方法来解决它。一个更简单的。

public static void main(String[] args) {

    String str= "aaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbcddddeeeeee";
    String str1 = "dbc";

    if(highestOccuredChar(str) != ' ')
    System.out.println("Most Frequently occured Character ==>  " +Character.toString(highestOccuredChar(str)));
    else
        System.out.println("The String doesn't have any character whose occurance is more than 1");
}

private static char highestOccuredChar(String str) {

    int [] count = new int [256];

    for ( int i=0 ;i<str.length() ; i++){
        count[str.charAt(i)]++;
    }

    int max = -1 ;
    char result = ' ' ;

    for(int j =0 ;j<str.length() ; j++){
        if(max < count[str.charAt(j)] && count[str.charAt(j)] > 1) {
            max = count[str.charAt(j)];
            result = str.charAt(j);
        }
    }

    return result;

}

回答by Akshay Talathi

public void countOccurrence(String str){
    int length = str.length();
    char[] arr = str.toCharArray();
    HashMap<Character, Integer> map = new HashMap<>();
    int max = 0;

    for (char ch : arr) {
        if(ch == ' '){
            continue;
        }
        if (map.containsKey(ch)) {
            map.put(ch, map.get(ch) + 1);
        } else {
            map.put(ch, 1);
        }
    }

    Set<Character> set = map.keySet();

    for (char c : set) {
        if (max == 0 || map.get(c) > max) {
            max = map.get(c);
        }
    }

    for (Character o : map.keySet()) {
        if (map.get(o).equals(max)) {
            System.out.println(o);
        }
    }
    System.out.println("");
}

public static void main(String[] args) {
    HighestOccurence ho = new HighestOccurence();

    ho.countOccurrence("aabbbcde");
}

回答by Alex Altman

public void stringMostFrequentCharacter() {
    String str = "My string lekdcd dljklskjffslk akdjfjdkjs skdjlaldkjfl;ak adkj;kfjflakj alkj;ljsfo^wiorufoi$*#&$ *******";
    char[] chars = str.toCharArray(); //optionally - str.toLowerCase().toCharArray();
    int unicodeMaxValue = 65535;    // 4 bytes
    int[] charCodes = new int[unicodeMaxValue];
    for (char c: chars) {
        charCodes[(int)c]++;
    }
    int maxValue = 0;
    int maxIndex = 0;
    for (int i = 0; i < unicodeMaxValue; i++) {
        if (charCodes[i] > maxValue) {
            maxValue = charCodes[i];
            maxIndex = i;
        }
    }
    char maxChar = (char)maxIndex;
    System.out.println("The most frequent character is >" + maxChar + "<  -  # of times: " + maxValue);
}

回答by Amit Sahay

For Simple String Manipulation, this program can be done as:

对于简单的字符串操作，这个程序可以这样完成：

package abc;
import java.io.*;

public class highocc 
{
        public static void main(String args[])throws IOException
        {
            BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("Enter any word : ");
            String str=in.readLine();
            str=str.toLowerCase();
            int g=0,count,max=0;;
            int ar[]=new int[26];
            char ch[]={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
                for(int i=0;i<ch.length;i++)
                {
                    count=0;
                    for(int j=0;j<str.length();j++)
                     {
                        char ch1=str.charAt(j);
                        if(ch[i]==ch1)
                            count++;
                     }
                   ar[i]=(int) count;
                }
                max=ar[0];
                for(int j=1;j<26;j++)
                {
                    if(max<ar[j])
                        {
                            max=ar[j];
                            g=j;
                        }
                }
                System.out.println("Maximum Occurence is "+max+" of character "+ch[g]);
           } 
}

Sample Input1: Pratik is a good Programmer

示例输入 1：Pratik 是一名优秀的程序员

Sample Output1: Maximum Occurence is 3 of character a

示例输出 1：最大出现次数为 3 个字符 a

Sample Input2: hello WORLD

示例输入 2：你好世界

Sample Output2: Maximum Occurence is 3 of character l

示例输出 2：最大出现次数为 3 个字符 l