JAVA-以字符串形式存储字母和字母数

Question

我应该要求用户输入一个字符串，并且我应该解析该字符串并跟踪字母的数字。 因此，就像用户输入字符串“ abee”一样，它将输出显示为：

a: 1
b: 1
c: 0
e: 2

到目前为止，我已经能够获取字符串并将其解析并将元素存储到数组中。 而且我能够使用for循环一次打印出每个字母。 现在我面临的问题是，当它打印出字母以及短语中存在多少个字母时，数字将不匹配。 例如，如果我输入字母：“ abccddee”，它将输出：

a: 1
b: 1
c: 1
c: 0
d: 0
d: 0
e: 0
e: 0

出于测试目的，我使用自己的字符串，而不是使用扫描仪。

import java.util.Scanner;

public class CountLetters
{

    public static void main(String[] args)
    {

        //create arrays
        String[] upper = new String[25];
        String[] lowerChar = new String[25];
        int [] lowerCharNum = new int[25];

        Scanner input = new Scanner(System.in);

        System.out.println("Please enter a phrase");

        //grab phrase from user
        String phrase = "abccddee";

        //create array with the size of the phrase entered from user
        String[] letters = new String[phrase.length()];
        System.out.println("letters length: " + letters.length);

        //separate every letter in phrase and store it into array "letters"
        letters = phrase.split("");

        for(int i=0; i<letters.length; i++)
        {
            lowerChar[i] = letters[i];
             switch(letters[i])
             {
               case "a":
                   lowerCharNum[0] += 1;
                   break;
               case "b":
                   lowerCharNum[1] += 1;
                   break;
               case "c":
                   lowerCharNum[2] += 1;
                   break;
               case "d":
                   lowerCharNum[3] += 1;
                   break;
               case "e":
                   lowerCharNum[4] += 1;
                   break;
               case "f":
                   lowerCharNum[5] += 1;
                   break;
            }//end of switch
            System.out.println(lowerChar[i] + ": " + lowerCharNum[i]);
        }
    }//end of main method
}//end of class

Answer 1

与其使用简单的数组，不如使用Java的Collection的HashMap 。

使用HashMap的主要工作是处理for循环，将检查HashMap是否已存在Character ，然后获取与Character相关的值，并将现有值加1，如果Character不存在然后我们将一个Character放入HashMap ，并将初始计数1与关联的角色一起存储。

        HashMap<Character, Integer> lettersCount = new HashMap<>();
        String phrase = "abccddee";
        int length = phrase.length();
        int count = 1;
        for (int i = 0; i < length; i++) {
        int integer = 0;
        char charAt = input.charAt(i);
        if (!lettersCount.containsKey(charAt)) {
            lettersCount.put(charAt, 0);
        }
        integer = lettersCount.get(charAt);
        integer = initialCount + integer;
        lettersCount.put(charAt, integer);
    }
    System.out.println(lettersCount);

您正在使用需要在声明时进行初始化的数组，这将创建一个额外的存储空间，如果没有全部遇到26个字母，并且按照您要分配的问题中提供的代码，这将是浪费的3数组，因此将占用更多的内存，因此，此解决方案将仅需要一个HashMap （ HashMap将根据HashMap插入的键和值分配内存）和一个for循环，该循环将仅计算Charater并再次使用在程序中使用它会更容易。

Answer 2

您正在for循环中进行打印。 您应该在该循环之外打印频率。

您使用的方法不可扩展。 假设该短语仅包含大写和小写英文字母，则您将必须在开关中编写52个大小写语句。

更好的方法是使用ASCII编码来达到目的。 您可以在以下几行中输入一些内容：

int frequency[] = new int[128];
for (int i = 0; i < phrase.length(); i++) {
    frequency[(int) phrase.charAt(i)]++;
}

在此方法中， frequency数组用于计算phrase字符串中前128个ASCII字符的出现次数。 操作(int) phrase.charAt(i)只是将字符转换为相应的ASCII代码，我们将该字符的计数器增加1。在处理结束时， frequency数组将包含出现的前128个ASCII字符的数目。给定的phrase字符串。 只需打印此频率即可获得所需的输出。

Answer 3

打印声明必须在 而 for循环。

System.out.println(lowerChar[i] + ": " + lowerCharNum[i]);

更新：您需要先解析整个字符串，然后开始打印。

import java.io.*;
import java.util.*;
 class CountLetters {

    public static void main(String[] args)
    {
int i;
          //create arrays
        String[] upper = new String[25];
        String[] lowerChar = new String[25];
        int [] lowerCharNum = new int[25];


        Scanner input = new Scanner(System.in);

        System.out.println("Please enter a phrase");

        //grab phrase from user
        String phrase = "abccddee";

        //create array with the size of the phrase entered from user
        String[] letters = new String[phrase.length()];
        System.out.println("letters length: " + letters.length);

        //seperate every letter in phrase and store it into array "letters"
        letters = phrase.split("");


        for(i=0; i<letters.length; i++)
        {
            lowerChar[i] = letters[i];
        switch(letters[i])
         {
         case "a":
            lowerCharNum[0] += 1;
             break;
         case "b":
            lowerCharNum[1] += 1;
             break;
         case "c":
            lowerCharNum[2] += 1;
             break;
         case "d":
            lowerCharNum[3] += 1;
             break;
         case "e":
            lowerCharNum[4] += 1;
             break;
         case "f":
            lowerCharNum[5] += 1;
             break;
         }//end of switch



        }

for(i=0;i<5;i++)
System.out.println(lowerChar[i] + ": " + lowerCharNum[i]);



    }//end of main method


}//end of class

Answer 4

数组的解决方案有点复杂。 通过使用Map，我们可以将遇到的字符与遇到它们的次数直接关联，从而非常直接地增加计数器并输出计数器，而不必在不同的数组中查找索引。

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class CountLetters
{

    public static void main(String[] args)
    {

        Scanner input = new Scanner(System.in);

        System.out.println("Please enter a phrase");

        //grab phrase from user
        String phrase = "abccddee";

        //create array with the phrase entered from user
        char[] letters = phrase.toCharArray();
        System.out.println("letters length: " + letters.length);

        // Map to keep track of all encountered characters and the
        // number of times we've encountered them
        Map<Character, Integer> characterCounts = new HashMap<>();
        for(int i=0; i<letters.length; i++)
        {
            Character character = letters[i];
            if(characterCounts.containsKey(character))
            {
                // We've encountered this character before, increase the counter
                characterCounts.put(character, characterCounts.get(character) + 1);
            }
            else
            {
                // This is the first time we encounter this character
                characterCounts.put(lowerChar, 1);
            }
        }

        // Iterate over all character-counter pairs and print them
        for(Map.Entry<Character, Integer> entry : characterCounts.entrySet())
        {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }//end of main method
}//end of class

Answer 5

• HashMap以无序的方式存储键和值，并且contains only unique keys.
• TreeMap以自然有序的方式存储键和值，并且contains only unique keys.
• LinkedHashMap按键插入的顺序存储键和值，并且contains only unique keys.

用于此要求的适当数据结构将是Map 。 如果要保持字母在字符串中出现的顺序，可以使用LinkedHashMap，如果字母顺序无关紧要，则可以使用HashMap。 我在示例中使用LinkedHashMap。

public class Test {

    public static void main(String[] args) {

        //Taking the input from the user
        System.out.println("Enter the String"); //I am entering "abccddee" for your example
        Scanner sc = new Scanner(System.in);
        String input = sc.next(); 

        //LinkedhashMap preserves the order in which input was supplied
        LinkedHashMap<Character, Integer> lhm = new LinkedHashMap<Character, Integer>();

        for(int i=0; i<input.length(); i++){

            //method get will return null if the letter is not available at the given index else it will return the count
            Integer j = lhm.get(input.charAt(i));

            //If the chracter was not present in the String
            if(j==null)
                lhm.put(input.charAt(i),1);
            //If the character was present in the String
             else
                lhm.put(input.charAt(i),j+1);

         }

         for(Character c : lhm.keySet())  
             System.out.println(c+": "+lhm.get(c)+" ");

    }

}

输出将是：

a: 1 
b: 1 
c: 2 
d: 2 
e: 2