字符统计

非常巧妙的方法，用TreeMap<Character, Integer>来记录字符串中每个字符出现的次数，
注意TreeMap是对key做排序的（词典序升序）,求出字符串中出现次数最多的字符次数为max。
当max > 0 时，遍历字符串，如果字符出现次数等于max，输出到控制台，遍历结束后，max--,
继续从头开始遍历字符串，找出现字数的max的字符并输出。当max == 0时结束遍历即可。
import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            String str = in.nextLine();
            TreeMap<Character, Integer> treemap = new TreeMap<>();
            int max = 0;
            for (char c : str.toCharArray()) {
                treemap.merge(c, 1, Integer :: sum);
                max = Math.max(treemap.get(c), max);
            }
            while (max > 0) {
                for (char c : treemap.keySet()) {
                    if (treemap.get(c) == max){
                        System.out.print(c);
                    }
                }
                max--;
            }

        }
    }
}

     Scanner sc=new Scanner(System.in);
        String str= sc.nextLine();
        TreeMap<Character,Integer> ts=new TreeMap<>();
        for (int i = 0; i < str.length(); i++) {
          ts.put(str.charAt(i),ts.getOrDefault(str.charAt(i),0)+1);
          }
        int max=0;
        while(!ts.isEmpty()) {
            Set<Character> characters = ts.keySet();
            Object[] array = characters.toArray();
            for (int i=0;i<array.length;i++) {
                if (ts.get(array[i]) >= max) {
                    max = ts.get(array[i]);
                }
            }
            for (int i=0;i<array.length;i++)  {
                if (ts.get(array[i]) == max) {
                    System.out.print(array[i]);
                    ts.remove(array[i]);
                }

            }
            max=0;
        }

import java.io.*;
import java.util.HashMap;
import java.util.stream.Collectors;
import java.util.List;

public class Main {
    public static void main(String[] args) throws IOException {
        HashMap<Character, Integer> h = new HashMap<>();
        int c;
        while ((c = System.in.read()) != '\n') {
            if (h.containsKey((char)c)) {
                h.put((char)c, h.get((char)c)+1);
            } else {
                h.put((char)c, 1);
            }
        }
        List<Character> s = h.keySet().stream().sorted((a, b)->{
            if (h.get(a) == h.get(b)) return a - b;
            return h.get(b)-h.get(a);
        }).collect(Collectors.toList());
        for (char t: s) {
            System.out.print(t);
        }
    }
}

看了大家的代码，感觉我这个思路挺独特，测试用例也过了
import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        TreeMap<Character, Integer> map = new TreeMap<>();
        for (char c : str.toCharArray()) {
            map.put(c, map.getOrDefault(c, 0) + 1);
        }
        Integer[] arr = map.values().toArray(new Integer[0]);
        Arrays.sort(arr, Comparator.reverseOrder());
        StringBuilder result = new StringBuilder();
        for (Integer count : arr) {
            for (Map.Entry<Character, Integer> entry : map.entrySet()) {
                Integer value = entry.getValue();
                Character key = entry.getKey();
                if (value.equals(count) && !result.toString().contains(String.valueOf(key))) {
                    result.append(key);
                }
            }
        }
        System.out.println(result);
    }
}

import java.util.Scanner;
import java.util.TreeMap;
import java.util.Arrays;
import java.util.Map;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        //1.TreeMap获取字符及数量，默认按字符升序排列
        TreeMap<Character, Integer> tm = new TreeMap();
        for (int i = 0; i < s.length(); i++) {
            if (tm.containsKey(s.charAt(i))) {
                int count = tm.get(s.charAt(i));
                tm.put(s.charAt(i), ++count);
            } else {
                tm.put(s.charAt(i), 1);
            }
        }
        //2.每次取出第一个出现次数最大值字符，拼接到sb中
        StringBuilder sb = new StringBuilder("");
        //Arrays.sort方法也可以实现，但是编译器不支持自定义排序函数使用
        while (!tm.isEmpty()) {
            int max = getMax(tm);
            for(Map.Entry<Character, Integer> entry :tm.entrySet()){
                if(entry.getValue()==max){
                    char c=entry.getKey();
                    sb.append(c);
                    //遍历过该字符，删除
                    tm.remove(c);
                    break;
                }
            }
        }
        System.out.print(sb.toString());

    }
    public static int getMax(TreeMap<Character, Integer> tm) {
        int max = 0;
        for (int num : tm.values()) {
            if (num > max) {
                max=num;
            }
        }
        return max;
    }
}

import java.util.*;


// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class emptyBowl {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        char[] array = s.toCharArray();
        int[] a = new int[128];
        for (char c : array) {
            a[(int) c]++;
        }
        int max = s.length();
        while (max > 0) {
            for (int i = 0; i < a.length; i++) {
                if (a[i] == max) {
                    System.out.print((char) i);
                }
            }
            max--;
        }
    }
}

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = in.nextLine();
        Map<Character, Integer> map = new HashMap();
        for (int i = 0; i < s.length(); i++) {
            map.put(s.charAt(i), map.getOrDefault(s.charAt(i), 0) + 1);
        }
        List<Map.Entry<Character, Integer>> list = new ArrayList<>(map.entrySet());
        Collections.sort(list, (o1, o2)-> {
            if (o1.getValue() != o2.getValue()) {
                return o2.getValue() - o1.getValue();
            } else {
                return o1.getKey().compareTo(o2.getKey());
            }
        });
        list.forEach( e -> System.out.print(e.getKey()));
    }
}

import java.util.Scanner;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line = br.readLine();

        // 统计每个字符的次数
        HashMap<Character, Integer> map = new HashMap<>();
        // 遍历
        for (int i = 0; i < line.length(); i++) {
            char c = line.charAt(i);
            map.put(c, map.getOrDefault(c, 0) + 1);
        }

        // 业务场景为按照key排序，并统计次数
        TreeMap<Integer, TreeSet<Character>> treeMap = new TreeMap<>
        (new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                // 按照次数降序
                return o2.compareTo(o1);
            }
        });

        // 放入treeMap中排序，按照次数降序，相同次数的字符，按照升序排序
        for (Map.Entry<Character, Integer> entry : map.entrySet()) {
            Integer value = entry.getValue();
            Character key = entry.getKey();
            TreeSet<Character> characters = treeMap.get(value);

            if (characters == null) {
                TreeSet<Character> treeSet = new TreeSet<>();
                treeSet.add(key);
                treeMap.put(value, treeSet);
            } else {
                characters.add(key);
            }
        }

        // 打印结果
        for (Map.Entry<Integer, TreeSet<Character>> entry : treeMap.entrySet()) {
            Integer key = entry.getKey();
            TreeSet<Character> value = entry.getValue();
            for (Character character : value) {
                System.out.print(character);
            }
        }
    }
}

import java.util.Scanner;
import java.util.HashMap;
import java.util.Collections;
import java.util.ArrayList;
import java.util.Comparator;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNextLine()) {
            String str = sc.nextLine();
            HashMap<Character, Integer> map = new HashMap<>();
            //把 字符-出现次数 放入HashMap中
            for (char ch : str.toCharArray()) {
                map.put(ch, map.getOrDefault(ch, 0) + 1);
            }
            // 再把字符放入ArrayList中，自定义比较器进行sort
            ArrayList<Character> chList = new ArrayList<>(map.keySet());
            Collections.sort(chList, new Comparator<Character>() {
                public int compare(Character c1, Character c2) {
                    int num = map.get(c2)-map.get(c1);
                    int num2 = num==0?c1 - c2:num;
                    return num2;
                }
            });
            //输出排序后的字符
            for (Character ch : chList) {
                System.out.print(ch.toString());
            }
            System.out.println();
        }
        sc.close();
    }
}

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        int n = str.length();
        HashMap<Character, Integer> map = new HashMap<>();
        for(int i = 0; i < n; i++){
            Character c = str.charAt(i);
            if(!map.containsKey(c))
                map.put(c, 1);
            else{
                map.put(c, map.get(c) + 1);
            }
        }
        Queue<Map.Entry<Character, Integer>> queue = new PriorityQueue<Map.Entry<Character, Integer>>((a, b) -> {
            if(a.getValue() > b.getValue())
                return -1;
            else if(a.getValue() < b.getValue())
                return 1;
            else if(a.getKey() < b.getKey())
                return -1;
            else
                return 1;
        });
        for(Map.Entry<Character, Integer> entry : map.entrySet()){
            queue.offer(entry);
        }
        StringBuffer buffer = new StringBuffer();
        while(!queue.isEmpty()){
            buffer.append(queue.poll().getKey());
        }
        System.out.println(buffer.toString());
    }
}

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) { // 注意 while 处理多个 case
            String str = in.next();
            //字符串转为字节数组
            char[] strChar = str.toCharArray();
            //int数组，下标用于表示ascll值，值代表出现的个数
            int[] chars = new int[129];
            //遍历字符数组，统计int数组下标代表的字符出现次数
            for (char c : strChar) {
                chars[(int)c]++;
            }
            //代表出现最多的一个字符出现的次数
            int max = 0;
            //遍历int数组出现最多的一个字符出现的次数
            for (int i = 0; i < chars.length; i++) {

                if (chars[i] > max)
                    max = chars[i];
            }
            StringBuilder sb = new StringBuilder();

            while (max != 0) {
                //下标(即ASCII值)从小到大遍历，保证了【如果统计的个数相同，则按照ASCII码由小到大排序输出。】的要求
                for (int i = 0; i < chars.length; i++) {
                    if (chars[i] == max)
                        sb.append((char)i);
                }
                max--;
            }
            System.out.println(sb.toString());
        }
    }
}

import java.util.Comparator;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNext()) { // 注意 while 处理多个 case
            TreeMap<Character, Integer> map = new TreeMap<>();
            for (char c : in.next().toCharArray()) {
                map.put(c, map.getOrDefault(c, 0) + 1);
            }
            map.entrySet().stream().sorted(Map.Entry.comparingByValue(Comparator.reverseOrder())).map(Map.Entry::getKey).forEach(System.out::print);
        }
    }
}