对 字符串中的字符、字串，进行统计，按重复度进行排序

——将字符串中的 字符or字串 按出现次数多少排序输出

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;


/**
 *  对 字符串中的字符、字串，进行统计，按重复度进行排序
 *  （将字符串中的 字符 按出现次数多少排序输出 ）
 * @author qing
 *
 */
public class StrORCharSort {
    public static void main(String[] args) {
        
        
        try {
            /*
             * // 键盘输入，转化 方式一 Scanner scanner = new Scanner(System.in); String
             * inputStr = scanner.nextLine();
             * System.out.println("scanner.nextLine():---" + inputStr);
             */
            // 键盘输入，转化 方式一
            // 接收，并读取 键盘输入内容，放入Buffer中（目前以流的形式存在）
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            
            // （1）将Buffer中的内容转换为String类型数据，
            // （2）合并 字符串中的 连续的空格 为一个
            String input = br.readLine().replaceAll("\s{1,}", " ");
            // 根据空格“ ”字符，将字符串 切割为 字符串数组
            String[] userStr = input.split(" ");
            
            // String系列            
            Map<String,Integer> map = new HashMap<String,Integer>();
            for (int i = 0; i < userStr.length; i++) {
                String tempStr = userStr[i];
                if(map.containsKey(tempStr)){
                    // 已经存在
                    Integer num = map.get(tempStr);
                    map.put(tempStr, num+1);
                }else {
                    // 首次出现
                    map.put(tempStr, 1);
                    System.out.println(tempStr);
                }
            }
            
            /*
            // char系列
            String strTemp = "aabcddefgg";
            char[] str = strTemp.toCharArray();
            
            Map<String,Integer> map = new HashMap<String,Integer>();
            for (int i = 0; i < str.length; i++) {
                String tempStr = String.valueOf(str[i]);
                if(map.containsKey(tempStr)){
                    // 已经存在
                    Integer num = map.get(tempStr);
                    map.put(tempStr, num+1);
                }else {
                    // 首次出现
                    map.put(tempStr, 1);
                    System.out.println(tempStr);
                }
            }*/
            
            // 将Map中的数据转存List中，便于 后面工具类Collections的排序处理
            List<Map.Entry<String, Integer>> list = new ArrayList<Map.Entry<String,Integer>>();
            list.addAll(map.entrySet());
            
            /**
             * 重写Collections工具类的sort()方法，
             * 对list中的entry，按照value值进行排列  
             */
            Collections.sort(list,new Comparator<Entry<String, Integer>>() {
                public int compare(Entry<String, Integer> arg0,Entry<String, Integer> arg1){
                    
                    /*
                     * 由少到多【升序】: arg0<---->arg1
                     * retrun arg0.getValue().compareTo(arg1.getValue());
                     */
                    
                    // 由多到少【降序】: arg1<---->arg0
                    return arg1.getValue().compareTo(arg0.getValue());
                }
            });
            
            // 循环取用  有序list 中Map.Entry中的数据
            for (int i = 0; i < list.size(); i++) {
                Map.Entry<String, Integer> mEntry = list.get(i);
                System.out.println("key:"+mEntry.getKey()+"   value:"+mEntry.getValue());
            }
                
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}