Question

我必须创建一个计算字符串中字母的程序，我对此有一点问题。

这是main中的代码：

Scanner sc = new Scanner(System.in);
String str;
int count;

System.out.println("Enter some text: ");
str = sc.nextLine();

char ch;

System.out.println("Letters: ");
for (ch = (char) 65; ch <= 90; ch++) {
    count = 0;
    for (int i = 0; i < str.length(); i++) {
        if (ch == str.charAt(i) || (ch + 32) == str.charAt(i)) {
            count++;
        }
    }
    if (count > 0) {
        System.out.println(ch + ": " + count);
    }
}

一切看起来都很好，但输出不应该按字母顺序排列，而是按降序字母数排序。

例如，如果您输入 Hello World ，输出应该是这样的：

L：3
  O：2
  H：1
  D：1
  E：1
  R：1
  W：1

输出将按字母频率的降序排序。这意味着最常见的字母应该首先出现，最少出现以相等比例出现的字母顺序必须按字母顺序排列。

Answer 1

问题是你的外部循环按字母顺序浏览字母，这就是你显示计数的地方。

我建议用一个循环浏览输入字符串，在遇到它们时更新Map<Character, Integer>中每个字母的数量。
然后，一旦消耗了输入String，我将按降序值对Map进行排序，并打印每个键/值对。

Map<Character, Integer> lettersCount = new HashMap<>();

for (int i=0; i <str.length(); i++) {
    Character current = str.charAt(i);
    if (Character.isLetter(current)) {
        Integer previousCount = lettersCount.get(current);
        if (previousCount != null) {
            lettersCount.put(current, previousCount + 1);
        } else {
            lettersCount.put(current, 1);
        }
    }
}
List<Map.Entry<Character, Integer>> list = new LinkedList<Map.Entry<Character, Integer>>( lettersCount.entrySet() );
Collections.sort( list, new Comparator<Map.Entry<Character, Integer>>()
{
    public int compare( Map.Entry<Character, Integer> o1, Map.Entry<Character, Integer> o2 )
    {
        return (o2.getValue()).compareTo( o1.getValue() );
    }
} );
for (Map.Entry<Character, Integer> entry : list) {
    System.out.println(entry.getKey() + " : " + entry.getValue());
}

您可以尝试on ideone。

正如您所看到的，按值排序Map并非易事： - /

Answer 2

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str;
        int count;

        System.out.println("Enter some text: ");
        str = sc.nextLine();

        char ch;

        System.out.println("Letters: ");
        LinkedHashMap<String, Integer> charCountMap = new LinkedHashMap<String, Integer>();
        for (ch = (char) 65; ch <= 90; ch++) {
            count = 0;
            for (int i = 0; i < str.length(); i++) {
                if (ch == str.charAt(i) || (ch + 32) == str.charAt(i)) {
                    count++;
                }
            }
            if (count > 0) {
                System.out.println(ch + ": " + count);
                charCountMap.put(ch + "", count);
            }

        }
        LinkedHashMap<String, Integer> sortedMapBasedOnValues = sortHashMapByValues(charCountMap);

        for (Map.Entry<String, Integer> entry : sortedMapBasedOnValues.entrySet()) {
            System.out.println("Key : " + entry.getKey() + " Value : " + entry.getValue());
        }

    }
    // Following method used from
    // http://stackoverflow.com/questions/8119366/sorting-hashmap-by-values

    public static LinkedHashMap<String, Integer> sortHashMapByValues(LinkedHashMap<String, Integer> passedMap) {
        List<String> mapKeys = new ArrayList<>(passedMap.keySet());
        List<Integer> mapValues = new ArrayList<>(passedMap.values());
        Collections.sort(mapValues, Collections.reverseOrder());
        Collections.sort(mapKeys);
        LinkedHashMap<String, Integer> sortedMap = new LinkedHashMap<>();

        Iterator<Integer> valueIt = mapValues.iterator();
        while (valueIt.hasNext()) {
            Integer val = valueIt.next();
            Iterator<String> keyIt = mapKeys.iterator();

            while (keyIt.hasNext()) {
                String key = keyIt.next();
                Integer comp1 = passedMap.get(key);
                Integer comp2 = val;

                if (comp1.equals(comp2)) {
                    keyIt.remove();
                    sortedMap.put(key, val);
                    break;
                }
            }
        }
        return sortedMap;
    }
}

Answer 3

如果您想对结果进行排序，那么您必须存储结果＆amp;然后按顺序迭代它们，按顺序打印

将它们存储到的最佳数据结构将是一个堆，从计数键入。 Java提供了像java.util.PriorityQueue这样的数据结构，它可以采用比较器函数，该函数首先比较count＆amp;然后是角色

https://docs.oracle.com/javase/7/docs/api/java/util/PriorityQueue.html

一个用Java计算字符串中字母数的程序

3 个答案: