将字符串中的字符按字符出现个数从大到小进行排序

最近同事出去面试，有个关于将字符串数组中的字符串按出现次数排序按从大到小，要求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     }

运性结果：

总结：

　　两种实现的方式核心思想都是一样的，主要考察对集合的掌握。

后话：很久没看，猛一接触还是挺懵逼的。记录下来也是对知识的一次回顾吧。

原文地址：https://www.cnblogs.com/zfding/p/8590219.html