Java 按降序排序的字符串

有人知道如何将字符串（例如：afacfa）排序为aaaffc吗？频率降序 我对编程非常陌生，只会想出一些新的方法

String word = (String)jTextField1.getText();
        String indexes = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
        int[] count = new int[indexes.length()];
        for (int i = 0; i < word.length(); i++) {
            int index = indexes.indexOf(word.charAt(i));

        System.out.println( "" + i + count[2] ) ;
        if (index < 0)
        continue;

    count[index]++;
        }
        for (int i = 0; i < count.length; i++) {
    if (count[i] < 1)
        continue;

    jTextArea1.append(String.format("%s (%d) %s",indexes.charAt(i),count[i],

            new String(new char[count[i]]).replace('\0', '*')));

---

您的算法还不错，您可以通过使用字符的ASCII值直接查找数组并保存indexOf步骤来加快速度

i、 对于大写字符，e.c-'A'是0到26之间的数字

此时，如果程序遇到映射数组中没有的任何字符，它就会崩溃

---

为了解决这个问题，你可以考虑使用一个从char到整数的映射来存储计数，当你找到它们时，在图的键中加上一个计数值，如果已经存在的话，将一个数递增一个。

如果你熟悉哈希映射，这个代码将很容易地做你想做的。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class MyPrg {
    public static void main(String[] args) {
        String name = "afacfa";

        System.out.println("Input Text = " + name);
        System.out.println("Result = " + arrangeCharactersInIncreasingOrderOfFrequency(name));

    }

    public static String arrangeCharactersInIncreasingOrderOfFrequency(String inputString) {
        String result = "";
        List<String> updatedStringList = new ArrayList<String>();

        for (int i = 0; i < inputString.length(); i++) {
            updatedStringList.add(inputString.substring(i, i + 1));
        }
        Collections.sort(updatedStringList);

        for (String abc : updatedStringList) {
            result = result.concat(abc);
        }
        return result;
    }
}

hashmap值是频率计数器，它通过在hashmap中查找最大值来打印输出

import java.util.Arrays;
import java.util.HashMap;

public class FrequencyPrint {
    public static void main(String[] args) {
        String s = "ccrrcdcffcghijk";
        HashMap<Character, Integer> hashMap = new HashMap<Character, Integer>();
        for (int i = 0; i < s.length(); i++) {
            if (hashMap.containsKey(s.charAt(i))) {
                int value = hashMap.get(s.charAt(i));
                hashMap.put(s.charAt(i), ++value);
            } else {
                hashMap.put(s.charAt(i), 1);
            }
        }

        Character keys[] = Arrays.copyOf(hashMap.keySet().toArray(), hashMap
                .keySet().toArray().length, Character[].class);
        Integer values[] = Arrays.copyOf(hashMap.values().toArray(), hashMap
                .values().toArray().length, Integer[].class);


        for (int i = 0; i < keys.length; i++) {
            int x = FrequencyPrint.findmax(values);
            for (int j = 0; j < values[x]; j++) {
                System.out.print(keys[x]);
            }
            values[x] = 0;
        }

    }

    public static int findmax(Integer values[]) {
        int max = 0;
        for (int i = 0; i < values.length; i++) {
            if (values[i] > values[max]) {
                max = i;
            }
        }
        return max;
    }
}

---

你的方法是正确的。我唯一的建议是考虑声明一个简短的类来保存关于字符的信息，例如静态类频率{char c；int计数；}，并将这些计数存储在这些数组中。让它们按照您的排序规则实现Compariable，您可以使用array.sort或Collections.sort进行排序。然后，当您迭代排序后的集合时，由于对象存储其字符，因此很容易创建输出字符串。我想这就是让我们所有人困惑的地方。你说的私人空虚是什么意思？请解释一下，以便我能正确回答