字符统计

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

import java.util.Scanner;
import java.util.Map;
import java.util.TreeMap;
import java.util.List;
import java.util.ArrayList;

// 注意类名必须为 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
            Map<Character, Integer> dataMap = new TreeMap<>();
            String input = in.nextLine();
            composeMap(input, dataMap);
            getResult(dataMap);
        }
    }

    private static void composeMap(String input,
                                   Map<Character, Integer> data) {
        // ASCII 码值从小到大存入TreeMap
        for (int i = 0; i < input.length(); i++) {
            char ch = input.charAt(i);
            if (data.containsKey(ch)) {
                int v = data.get(ch);
                v = v + 1;
                data.put(ch, v);
            } else {
                data.put(ch, 1);
            }
        }
    }

    private static void getResult(Map<Character, Integer> data) {
        StringBuilder sb = new StringBuilder();
        while (!data.isEmpty()) {
            int max = 0;
            int count = 0;
            // 依次获取最大值，删除
            for (char key : data.keySet()) {
                int value = data.get(key);
                if (value > max) {
                    max = value;
                }
            }
            List<Character> list = new ArrayList<>();
            for (char key : data.keySet()) {
                if (max == data.get(key)) {
                    list.add(key);
                }

            }
            //放入列表中删除
            for (int i = 0; i < list.size(); i++) {
                char cha = list.get(i);
                sb.append(cha);
                data.remove(cha);
            }
        }
        System.out.println(sb.toString());
    }

}

import java.util.Scanner;
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.hasNext()) { // 注意 while 处理多个 case
            String str = in.next();
            TreeMap<Character, Integer> map = new TreeMap<>();
            for (int i = 0; i < str.length(); i++) {
                char c = str.charAt(i);
                if (map.containsKey(c)) {
                    int count = map.get(c);
                    map.put(c, ++count);
                } else {
                    map.put(c, 1);
                }
            }
            int maxCount = 0;
            Set<Character> set = map.keySet();
            for (Character c : set) {
                int count = map.get(c);
                if (count > maxCount) {
                    maxCount = count;
                }
            }
            while (maxCount > 0) {
                for (Character c : set) {
                    int count = map.get(c);
                    if (count == maxCount) {
                        System.out.print(c);
                    }
                }
                maxCount--;
            }
            System.out.println();

        }
    }
}

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

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            String string = sc.nextLine();
            HashMap<Character, Integer> hashMap = new HashMap<>();
            for (char ch : string.toCharArray()) {
                if (hashMap.containsKey(ch)) {
                    hashMap.put(ch, hashMap.get(ch) + 1);
                } else {
                    hashMap.put(ch, 1);
                }
            }
            Set<Map.Entry<Character, Integer>> entrySet = hashMap.entrySet();
            ArrayList<Map.Entry<Character, Integer>> list = new ArrayList<>(entrySet);
            Collections.sort(list, new Comparator<Map.Entry<Character, Integer>>() {
                @Override
                public int compare(Map.Entry<Character, Integer> o1, Map.Entry<Character, Integer> o2) {
                    if (o1.getValue() == o2.getValue()) {
                        return o1.getKey() - o2.getKey();
                    } else {
                        return o2.getValue() - o1.getValue();
                    }
                }
            });
            for (Map.Entry<Character, Integer> entry : list) {
                System.out.print(entry.getKey());
            }
            System.out.println();
        }
    }
}

import java.util.*;

/**
 * 一个字符串，为不同字母出现次数的降序表示。若出现次数相同，则按ASCII码的升序输出。
 * 示例1
 * 输入：
 * aaddccdc
 * 输出：
 * cda
 * 说明：
 * 样例里，c和d出现3次，a出现2次，但c的ASCII码比d小，所以先输出c，再输出d，最后输出a.
 */
public class HJ102_treemap加比较 {
    public static void main(String[] args) {
        TreeMap<Character, Integer> abc=new TreeMap<>();
        Scanner sc=new Scanner(System.in);
        String s=sc.nextLine();
        char c;
        for (int i = 0; i < s.length(); i++) {
            c=s.charAt(i);
            if(!abc.containsKey(c))
                abc.put(c,1);
            else
                abc.put(c,abc.get(c)+1);
        }
        ArrayList<Map.Entry<Character, Integer>> list=new ArrayList<>(abc.entrySet());
        list.sort(new Comparator<Map.Entry<Character, Integer>>() {
            @Override
            public int compare(Map.Entry<Character, Integer> o1, Map.Entry<Character, Integer> o2) {//compare方法return负数表示反转，0和正数不变，o2在o1前，故o1-o2从小到大
                if (o2.getValue()-o1.getValue()==0)//值相等比较ASCII码,小的在前
                    return o1.getKey()-o2.getKey();
                else
                    return o2.getValue()-o1.getValue();//value不同，值大的在前
            }
        });
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i).getKey());
        }
    }
}