计算要显示的相同字母数 import java.util.Scanner； 公共课abc{ 公共静态void main（字符串[]args）{ char[]ch=str.toCharArray（）； int len=通道长度； 对于（int i=0；i0）{ //使用数字格式添加到集合（有序…） 已排序的.add（nf.format（counte）+“-”+c）； } } //将集合连接在一起以创建输出字符串 细木工sj=新细木工（“，”）； for（字符串s：已排序）{ //修剪掉前导零 sj.add（s.replaceAll（“\\G0”和“）； } //输出 System.out.println（sj.toString（））； } }

输入：

BBBBBBBBCCoooppu

输出：

5-B、6-B、2-C、4-o、3-p、1-u

但我希望输出是：

6-b、5-b、4-o、3-p、2-C、1-u

---

如何解决此问题？

使用java.util中的类检查此示例代码

import java.util.Scanner;

public class abc {
    public static void main(String[] args) {
        char[] ch = str.toCharArray();
        int len = ch.length;

        for (int i = 0; i < len; i++) {
            int counte = 0;
            char c = str.charAt(i);

            for (int j = 0; j < len; j++) {
                if (c == ch[j]) {
                    counte++;
                    ch[j] = '\u0000';
                }
            }

            if (counte > 0) System.out.print(c + "-" + counte + ",");
        }
    }
}

import java.util.*；
导入java.text.*；
公共课abc{
公共静态void main（字符串[]args）{
//字符串作为参数。应为args[0]；还是其他？
String str=“bbbbbbbbccoooppu”；
//带前导零的格式，允许最多999次排序
NumberFormat nf=新的十进制格式（“000”）；
//创建反向排序集以保留计数
Set sorted=新树集（Collections.reverseOrder（））；
[…]//像以前一样做你的事。。。
如果（计数>0）{
//使用数字格式添加到集合（有序…）
已排序的.add（nf.format（counte）+“-”+c）；
}
}
//将集合连接在一起以创建输出字符串
细木工sj=新细木工（“，”）；
for（字符串s：已排序）{
//修剪掉前导零
sj.add（s.replaceAll（“\\G0”和“）；
}
//输出
System.out.println（sj.toString（））；
}
}

不要打印值

5-B

，

6-B

等。。但将其值存储在数组中，出现的次数将是关键：

import java.util.*;
import java.text.*;

public class abc {
    public static void main(String[] args) {
        //String as parameter. Should be args[0]; or something?
        String str = "BBBBBbbbbbbCCooooPPPu"; 
        //Format with leading zeros to allow sorting up to 999
        NumberFormat nf = new DecimalFormat("000");

        //Create reverse-sorted set to hold counts
        Set<String> sorted = new TreeSet<String>(Collections.reverseOrder() );
        [...] //Do your thing as before...
            if (counte > 0) {
                //Add to Set (ordered...) using number format
                sorted.add(nf.format(counte) + "-" + c);
            }
        }
        //Join together set to create output String
        StringJoiner sj = new StringJoiner(",");
        for(String s : sorted) {
            //Trim away leading zeros
            sj.add(s.replaceAll("\\G0", ""));
        }
        //Output
        System.out.println(sj.toString());
    }
}

最后，只需使用一些排序函数来反转这个数组。

您需要进行排序

下面的代码就是这样做的，不管字母是否连续

result[5] = '5-B';
result[6] = '6-b';
// etc...

publicstaticvoid见字符串（）
{
List lp=new ArrayList（）；
Map mci=newhashmap（）；
//填充
String str=“mylongstringtoscannandsomore”；
str=“bbbbbbbbccoooppu”；
int size=str.length（）；
对于（int pos=0；pos列表
对于（Map.Entry e:mci.entrySet（））
lp.add（新对（e.getValue（），e.getKey（））；
//分类
反向排序（lp）；
size=lp.size（）；
//看
对于（int pos=0；pos，这是使用lambdas实现您的需求的最简单方法

public static void see_string () 
{
    List<Pair<Integer,String>> lp=new ArrayList<Pair<Integer,String>>();
    Map<String, Integer> mci=new HashMap<String, Integer>();

    // Populate
    String str="mylongstringtoscanandsomore";
    str="BBBBBbbbbbbCCooooPPPu";

    int size=str.length();

    for (int pos=0;pos<size;pos++)
        {
        String ch=str.substring(pos,pos+1);
        int val=0;
        if (mci.containsKey(ch)) {val=mci.get(ch);}
        val++;
        mci.put(ch, val);
        }

    // map => list
    for (Map.Entry<String, Integer> e : mci.entrySet())
        lp.add(new Pair<Integer,String>(e.getValue(),e.getKey()));

    // SORT
    reverse_sort(lp);

    size=lp.size();

    // See
    for (int pos=0;pos<size;pos++)
        {
        System.out.println(lp.get(pos).getLeft()+"=>"+lp.get(pos).getRight());
        }

}

// http://stackoverflow.com/questions/521171/a-java-collection-of-value-pairs-tuples

public class Pair<L,R> implements java.io.Serializable  {

      private final L left;
      private final R right;

      public Pair(L left, R right) {
        this.left = left;
        this.right = right;
      }

      public L getLeft() { return left; }
      public R getRight() { return right; }

      @Override
      public int hashCode() { return left.hashCode() ^ right.hashCode(); }

      @Override
      public boolean equals(Object o) {
        if (o == null) return false;
        if (!(o instanceof Pair)) return false;
        Pair pairo = (Pair) o;
        return this.left.equals(pairo.getLeft()) &&
               this.right.equals(pairo.getRight());
      }

    }


// T key to sort
static public <T extends Comparable<T>, Object,K extends Object> 
void reverse_sort(List<Pair<T,K>> _list)
{

    class ComparaterTK <T extends Comparable<T>,K> implements Comparator<Pair<T,K>>
    {
      public int compare(Pair<T,K> ob1, Pair<T,K> ob2)
        {
          return ob2.getLeft().compareTo(ob1.getLeft());
      }
    }

    // simple sort
    Collections.sort(_list, new ComparaterTK<T,K>());
}

String String=“bbbbbbbbccoooppu”；
Stream.of（string.split（“”）
.collect（收集器.groupingBy（s->s，收集器.counting（））
.entrySet（）.stream（）。
排序（（Map.Entry o1，Map.Entry o2）->o2.getValue（）.compareTo（o1.getValue（）））。
forEachOrdered（e->System.out.print（e.getValue（）+“-”+e.getKey（）+”，”）；
请格式化您的代码。9之后您将遇到问题，然后您必须格式化数字。当然@guillaumegirod vitouchkina，在将所有数字作为索引分配给数组之前，所有数字都应转换为int。更准确地说，如果您想按词汇对数字进行排序，您必须在之前添加000，或者我的意思是写入方法和数组t字母，即A-Z，A-Z。和，以什么方式调用前十个最常用的字母？我给出的示例已按字节数降序排列。您还需要改进什么？（任何您可以通过首先接受答案来激励我；-）查看完整的代码可能会有所帮助-您的代码甚至不会编译，因为str是未定义的。9之后您将遇到问题，然后您必须格式化数字。这是最好的代码，但我认为这有一个简单的代码来完成。我的代码当然可以改进，但我更喜欢清晰。1您必须计数。一个简单的循环可以完成。2您必须按数量排序或者你可以使用在字符前面加上数量的技巧。注意也要加上0。
 String string = "BBBBBbbbbbbCCooooPPPu";
 Stream.of(string.split(""))
            .collect(Collectors.groupingBy(s -> s, Collectors.counting()))
            .entrySet().stream().
            sorted((Map.Entry<String, Long> o1, Map.Entry<String, Long> o2) -> o2.getValue().compareTo(o1.getValue())).
            forEachOrdered(e -> System.out.print(e.getValue() + " - " + e.getKey()+", "));