最近同事出去面試，有個關於將字符串數組中的字符串按出現次數排序按從大到小，要求5分鐘之內寫出來。很尷尬，沒有寫出來。我也來一次回顧吧

對於這種：

1 String stri = "agasdfasdfdccvvasdfg";

或者這種

1 String str = "a,b,c,a,v,d,f,s,s,f,f,sd";

其實都是一樣的。

第一種實現：

思路：1.將其轉化為數組，2.定義一個map,key為字符/字符串的值，value為出現的次數

　　　3.將map的value集合進行排序，這個排序是從大到小的排序

　　　4.遍歷排序後的value集合，如果原map中包含這個value，將重新將key和value寫入到linkedHashMap中去

代碼實現：

 1 public class TestSortDemo1 {
 2     public static void main(String[] args) {
 3         String str = "agadfsffdfvasdf";
 4         final char[] chars = str.toCharArray();
 5         Map<Character,Integer> map = new HashMap<>();
 6         for (char aChar : chars) {
 7             if
 
(map.containsKey(aChar)){
 8                 map.put(aChar,map.get(aChar)+1);
 9             }else {
10                 map.put(aChar,1);
11             }
12         }
13         System.out.println(map);
14         List<Integer> list = new ArrayList<>();
15         for (Integer integer : map.values()) {
 
16             list.add(integer);
17         }
18         //將values進行排序
19         Collections.sort(list); //正序
20         //Collections.sort(list,Comparator.reverseOrder()); //逆序
21         System.out.println(list);
22         LinkedHashMap<Character,Integer> linkedHashMap = new LinkedHashMap<>();//不會改變插入的順序
23         for (Integer value : list) {
24             for (Character character : map.keySet()) {
25                 if(map.get(character)==value){
26                     linkedHashMap.put(character,value);
27                 }
28             }
29         }
30         System.out.println(linkedHashMap);
31         System.out.println(linkedHashMap.keySet());
32     }
33 }

運行的結果：

切換到正序運行結果：

另一種實現方式：在第三步以後略有不同，但是思想基本是相同的，3.將map轉為entryset,封裝進list裏面4，調用collections.sort方法，重寫比較方法

具體代碼實現：

 1 public static void main(String[] args) {
 2         String str = "agadfsffdfvasdf";
 3         final char[] chars = str.toCharArray();
 4         Map<Character, Integer> map = new HashMap<>();
 5         for (char aChar : chars) {
 6             if (map.containsKey(aChar)) {
 7                 map.put(aChar, map.get(aChar) + 1);
 8             } else {
 9                 map.put(aChar, 1);
10             }
11         }
12         System.out.println(map);
13         List<Map.Entry<Character,Integer>> list = new ArrayList<>();
14         list.addAll(map.entrySet());
15         Collections.sort(list, new Comparator<Map.Entry<Character, Integer>>() {
16             @Override
17             public int compare(Map.Entry<Character, Integer> o1, Map.Entry<Character, Integer> o2) {
18                 return o2.getValue() - o1.getValue();//從大到小
　　　　　　　　　　　//return o1.getValue() - o2.getValue();//從小到大
19             }
20         });
21         System.out.println("從大到小的順序：");
22         for (Map.Entry<Character, Integer> characterIntegerEntry : list) {
23             System.out.print(characterIntegerEntry.getKey()+",");
24         }
25     }

運性結果：

總結：

　　兩種實現的方式核心思想都是一樣的，主要考察對集合的掌握。

後話：很久沒看，猛一接觸還是挺懵逼的。記錄下來也是對知識的一次回顧吧。

將字符串中的字符按字符出現個數從大到小進行排序