一個計算Java中字符串的字母的程序

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
○：2
H：1
d：1
Ë ：1
R：1
寬：1

輸出將按字母頻率降序排列。這意味着最頻繁的信件應該首先出現，最後一次出現。
以相同比例出現的字母順序必須按字母順序排列。

Answer 1

如果要對結果進行排序，那麼你就必須存儲結果&然後通過他們的數量遞減爲了

最好的數據結構來存儲它們打印遍歷他們進入將是一個堆，關閉計數。 Java的提供這樣的數據結構java.util.PriorityQueue中可以採取哪些首先比較比較函數計算&然後字符

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

Answer 2

的問題是，你的外環瀏覽按字母順序排列的字母，這是你在哪裏顯示計數。

我會建議瀏覽一個循環的輸入字符串，在我遇到它時更新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 3

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; 
    } 
}