如何根据与Java 7兼容的出现顺序对单词的字母进行排序？_Java_String_Sorting_Oop

如何根据与Java 7兼容的出现顺序对单词的字母进行排序？

java string sorting oop

如何根据与Java 7兼容的出现顺序对单词的字母进行排序？,java,string,sorting,oop,Java,String,Sorting,Oop,我需要打印单词中出现的所有字母，重新排列，以便在开头找到出现频率最高的字母该单词最多可包含100000个字符如果有相同次数的字母出现，则按字母顺序排序后，将首先显示最小的字母 Java中的某些类和操作速度较慢。因此，建议使用BufferedReader和BufferedWriter 使用字符串进行连接很慢输入：说明输出：iinnssttcour public class Main { public static void main(String[] args) throws IOExce

我需要打印单词中出现的所有字母，重新排列，以便在开头找到出现频率最高的字母

该单词最多可包含100000个字符

如果有相同次数的字母出现，则按字母顺序排序后，将首先显示最小的字母

Java中的某些类和操作速度较慢。因此，建议使用BufferedReader和BufferedWriter

使用字符串进行连接很慢

输入：说明

输出：iinnssttcour

public class Main {
public static void main(String[] args) throws IOException {
 String line;
 BufferedReader reader = new BufferedReader(new 
 InputStreamReader(System.in));
 line = reader.readLine();

     StringBuilder sb = new StringBuilder();
     Map<Character, Integer> charCountMap = new HashMap<>();

     int len = line.length();

      for(int i = 0; i < len; i++) {
           char ch = line.charAt(i);
           charCountMap.put(ch, charCountMap.getOrDefault(ch, 0) + 1);
      }

      charCountMap.entrySet().stream()
                  .sorted(Map.Entry.<Character, 
     Integer>comparingByValue().reversed())
                 .forEach(record -> {
                    Character key = record.getKey();
                    int value = record.getValue();

                    for(int i = 0; i < value; i++) {
                          sb.append(key);
                     }
        });

        sb.toString();
        System.out.println(sb);
     }
  }

公共类主{
公共静态void main（字符串[]args）引发IOException{
弦线；
BufferedReader读取器=新的BufferedReader（新的
InputStreamReader（System.in））；
line=reader.readLine（）；
StringBuilder sb=新的StringBuilder（）；
Map charCountMap=newhashmap（）；
int len=line.length（）；
对于（int i=0；i{
Character key=record.getKey（）；
int value=record.getValue（）；
for（int i=0；i


我的第二个解决方案是工作太慢
public class Main {
public static void main(String[] args) throws IOException {
String inputString;
BufferedReader reader = new BufferedReader(new 
InputStreamReader(System.in));
inputString = reader.readLine();
if(reader != null)
 reader.close();
    int[] letterArray = new int[26];
    char[] letters = new char[26];
    for(int i=0;i<=25;i++)
        letters[i] = (char)(97+i);
    for(int i=0; i< inputString.length(); i++)
        letterArray[inputString.charAt(i) - 97] +=1 ;
    for(int i=0; i<=24;i++)
        for(int j=i+1;j<=25;j++){
            if(letterArray[i] <letterArray[j] || (letterArray[i] == 
               letterArray[j] && letters[i] > letters[j])){
                int temp = letterArray[i];
                letterArray[i] = letterArray[j];
                letterArray[j] = temp;
                char temp2;
                temp2 = letters[i];
                letters[i] = letters[j];
                letters[j] = temp2;}
        }
      String outputString = new String();
        for(int i=0;i<=25;i++){
            for(int j = 0; j<letterArray[i]; j++)
                outputString += letters[i];}
     System.out.println(outputString);}
     }

公共类主{
公共静态void main（字符串[]args）引发IOException{
字符串输入字符串；
BufferedReader读取器=新的BufferedReader（新的
InputStreamReader（System.in））；
inputString=reader.readLine（）；
if（读卡器！=null）
reader.close（）；
int[]letterArray=新int[26]；
字符[]个字母=新字符[26]；
对于（int i=0；i您就快到了。需要按反转的值对地图进行排序，然后按键进行排序。
问题是地图只按字母频率排序Map.Entry.comparingByValue（）.reversed（）
之后，它应该按字母顺序排序
您可以使用比较器。比较（…）。然后比较（…）
来实现排序的“之后”部分
valueComparator
按字母频率排序：
Comparator<Entry<Character, Integer>> valueComparator = (e1, e2) -> 
                e2.getValue().compareTo(e1.getValue());  // reverse order 

试试这个：
StringBuilder sb = new StringBuilder();
Map<Character, Integer> charCountMap  = new HashMap<>();

for (char c : line.toCharArray()) {
    charCountMap.put(c, charCountMap.getOrDefault(c, 0) + 1);
}

Comparator<Entry<Character, Integer>> valueComparator = (e1, e2) -> e2.getValue().compareTo(e1.getValue());
Comparator<Entry<Character, Integer>> keyComparator = valueComparator
        .thenComparing((e1, e2) -> e1.getKey().compareTo(e2.getKey()));

charCountMap.entrySet().stream().sorted(keyComparator).forEach(e -> {
    int i = 0;
    while (i < e.getValue()) {
        sb.append(e.getKey());
        i++;
    }
});

System.out.println(sb.toString());

你就快到了：）
正如在评论中提到的，您需要编写自己的比较器，以便根据计数和字符对映射的条目进行排序
public void main(String[] args) throws IOException {
    String line;
    line = "instructions"; // I've left out the Reader for brevity's sake

    StringBuilder sb = new StringBuilder();
    Map<Character, Integer> charCountMap = new HashMap<>();

    int len = line.length();

    for (int i = 0; i < len; i++) {
        char ch = line.charAt(i);
        charCountMap.put(ch, charCountMap.getOrDefault(ch, 0) + 1);
    }

    charCountMap.entrySet().stream().sorted((first, second) -> {
        if (first.getValue() > second.getValue())
            return -1;
        if (first.getValue().equals(second.getValue()))
            return first.getKey() - second.getKey();
        return 1;
    }).forEach(record -> {
                Character key = record.getKey();
                int value = record.getValue();

                for (int i = 0; i < value; i++) {
                    sb.append(key);
                }
            });

    System.out.println(sb.toString());
}

public void main（字符串[]args）引发IOException{
弦线；
line=“instructions”；//为了简洁起见，我省略了读者
StringBuilder sb=新的StringBuilder（）；
Map charCountMap=newhashmap（）；
int len=line.length（）；
对于（int i=0；i{
if（first.getValue（）>second.getValue（））
返回-1；
if（first.getValue（）.equals（second.getValue（）））
返回first.getKey（）-second.getKey（）；
返回1；
}).forEach（记录->{
Character key=record.getKey（）；
int value=record.getValue（）；
for（int i=0；i

比较器（这里声明为函数接口）首先检查字母的计数。只有当它们相等时，它还检查字符的位置
更新：Java7
Java7无法处理Streams/Lambdas/…因此我们必须更详细一些，但我们仍然可以实现同样的目标
public class Main {
    public static void main(String[] args) throws IOException {
        String inputString;
        BufferedReader reader = new BufferedReader(new
                InputStreamReader(System.in));
        inputString = reader.readLine();
        reader.close();

        Map<Character, Integer> charCountMap = new HashMap<>();

        int len = inputString.length();

        for (int i = 0; i < len; i++) {
            char ch = inputString.charAt(i);
            // getOrDefault is not available for Java 7
            Integer currentValue = charCountMap.get(ch);
            if (currentValue == null)
                currentValue = 0;
            charCountMap.put(ch, currentValue + 1);
        }

        // Conversion of Map to List is somewhat more complicated
        List<Map.Entry<Character, Integer>> charCountList = new ArrayList<>(charCountMap.entrySet());

        // Functional Interfaces / Lambdas do not yet exist so we need to declare the comparator explicitly
        Comparator<Map.Entry<Character, Integer>> comparator = new Comparator<Map.Entry<Character, Integer>>() {
            @Override
            public int compare(Map.Entry<Character, Integer> first, Map.Entry<Character, Integer> second) {
                if (first.getValue() > second.getValue())
                    return -1;
                if (first.getValue().equals(second.getValue()))
                    return first.getKey() - second.getKey();
                return 1;
            }
        };

        Collections.sort(charCountList, comparator);

        // StringBuilder does already exist
        StringBuilder sb = new StringBuilder();
        for (Map.Entry<Character, Integer> entry : charCountList) {
            Character key = entry.getKey();
            int value = entry.getValue();

            for (int i = 0; i < value; i++) {
                sb.append(key);
            }
        }
        System.out.println(sb.toString());
    }
}

公共类主{
公共静态void main（字符串[]args）引发IOException{
字符串输入字符串；
BufferedReader读取器=新的BufferedReader（新的
InputStreamReader（System.in））；
inputString=reader.readLine（）；
reader.close（）；
Map charCountMap=newhashmap（）；
int len=inputString.length（）；
对于（int i=0；isecond.getValue（））
返回-1；
if（first.getValue（）.equals（second.getValue（）））
返回first.getKey（）-second.getKey（）；
返回1；
}
};
Collections.sort（charCountList，comparator）；
//StringBuilder已存在
StringBuilder sb=新的StringBuilder（）；
用于（Map.Entry:charCountList）{
Character key=entry.getKey（）；
int value=entry.getValue（）；
for（int i=0；i

我已经评论了Java 7/8版本之间的差异，但它看起来仍然非常相似，不是吗
您的代码示例也可以运行，但您正在重新设计轮子，使所有的重数组都可以工作。换句话说：它可以工作，但不漂亮；）嗨，请告诉我们
public void main(String[] args) throws IOException {
    String line;
    line = "instructions"; // I've left out the Reader for brevity's sake

    StringBuilder sb = new StringBuilder();
    Map<Character, Integer> charCountMap = new HashMap<>();

    int len = line.length();

    for (int i = 0; i < len; i++) {
        char ch = line.charAt(i);
        charCountMap.put(ch, charCountMap.getOrDefault(ch, 0) + 1);
    }

    charCountMap.entrySet().stream().sorted((first, second) -> {
        if (first.getValue() > second.getValue())
            return -1;
        if (first.getValue().equals(second.getValue()))
            return first.getKey() - second.getKey();
        return 1;
    }).forEach(record -> {
                Character key = record.getKey();
                int value = record.getValue();

                for (int i = 0; i < value; i++) {
                    sb.append(key);
                }
            });

    System.out.println(sb.toString());
}

public class Main {
    public static void main(String[] args) throws IOException {
        String inputString;
        BufferedReader reader = new BufferedReader(new
                InputStreamReader(System.in));
        inputString = reader.readLine();
        reader.close();

        Map<Character, Integer> charCountMap = new HashMap<>();

        int len = inputString.length();

        for (int i = 0; i < len; i++) {
            char ch = inputString.charAt(i);
            // getOrDefault is not available for Java 7
            Integer currentValue = charCountMap.get(ch);
            if (currentValue == null)
                currentValue = 0;
            charCountMap.put(ch, currentValue + 1);
        }

        // Conversion of Map to List is somewhat more complicated
        List<Map.Entry<Character, Integer>> charCountList = new ArrayList<>(charCountMap.entrySet());

        // Functional Interfaces / Lambdas do not yet exist so we need to declare the comparator explicitly
        Comparator<Map.Entry<Character, Integer>> comparator = new Comparator<Map.Entry<Character, Integer>>() {
            @Override
            public int compare(Map.Entry<Character, Integer> first, Map.Entry<Character, Integer> second) {
                if (first.getValue() > second.getValue())
                    return -1;
                if (first.getValue().equals(second.getValue()))
                    return first.getKey() - second.getKey();
                return 1;
            }
        };

        Collections.sort(charCountList, comparator);

        // StringBuilder does already exist
        StringBuilder sb = new StringBuilder();
        for (Map.Entry<Character, Integer> entry : charCountList) {
            Character key = entry.getKey();
            int value = entry.getValue();

            for (int i = 0; i < value; i++) {
                sb.append(key);
            }
        }
        System.out.println(sb.toString());
    }
}