Java 使用映射生成的对象对优先级队列进行排序（值）

我的优先级队列有问题，无法正确排序对象值

我的代码获取一个文本字符串，并获取唯一字符的数量，同时计算每个唯一字符的频率。然后将其放入字符和整数类型的映射中，并分别指定键和值

然后，它获取映射的每个条目并将其放入一个PQNode对象（也是Character、Integer类型），然后将其提供给优先级队列

优先级队列是通过PQNode.java中的compareTo方法，按照从最低到最高的频率（值）对PQNode进行排序

我曾尝试在网上搜索，并试图将其放入一个列表中进行排序，但没有成功

public class Counting { 
public Counting(String text) {
    text = "mississippi river";
    Queue<PQNode> fringe = new PriorityQueue<>(); 
    char[] letters = text.toCharArray(); 
    Map<Character, Integer> frequency = new HashMap<>(); 

    for(char letter : letters) {
        if(frequency.containsKey(letter)) { 
            frequency.put(letter, frequency.get(letter) + 1);
        }
        else {frequency.put(letter, 1);} 
        }

    for(Map.Entry<Character, Integer> element : frequency.entrySet()) {
        PQNode pqN = new PQNode(element.getKey(), element.getValue());
        fringe.offer(pqN); 
    }
    System.out.println(fringe);
    }
}

公共类计数{
公共计数（字符串文本）{
text=“密西西比河”；
队列边缘=新的优先级队列（）；
char[]字母=text.toCharArray（）；
映射频率=新HashMap（）；
用于（字符：字母）{
if（frequency.containsKey（字母））{
频率.put（字母，频率.get（字母）+1）；
}
else{frequency.put（字母，1）；}
}
for（Map.Entry元素：frequency.entrySet（））{
PQNode pqN=新的PQNode（element.getKey（），element.getValue（））；
附带报价（pqN）；
}
系统输出打印LN（边缘）；
}
}

公共类PQNode实现可比较{
字符c；
国际频率；
公共PQNode（字符c，整数频率）{
这个.c=c；
this.freq=freq；
}
公共字符串toString（）{
返回“[c=“+c+”，freq=“+freq+”]”；
}
公共整数比较（PQNode otherFreq）{
返回整数.compare（this.freq，otherFreq.freq）；
}
}

预期产出为： [c=，freq=1]，[c=e，freq=1]，[c=v，freq=1]，[c=m，freq=1]，[c=p，freq=2]，[c=r，freq=2]，[c=s，freq=4]，[c=i，freq=5]

但实际产出是： [c=，freq=1]，[c=e，freq=1]，[c=v，freq=1]，[c=m，freq=1]，[c=p，freq=2]，[c=r，freq=2]，[c=i，freq=5]，[c=s，freq=4]

---

当频率等于1时，顺序并不重要，但最后两个元素的顺序错误。有什么想法吗？

PriorityQueue

不保证它会被排序

PriorityQueue

保证从

poll

和

peek

接收的下一个项目最少。如果您想让您的项目井然有序，您必须逐个轮询它们，而不是按原样打印

PriorityQueue

---

如果您正在寻找一个将被排序的结构，那么

树集

可能更好，或者可能是一个普通的旧

数组列表

，在插入所有元素后显式地

排序。
优先级队列
并不保证它会被排序
PriorityQueue
保证从
poll
和
peek
接收的下一个项目最少。如果您想让您的项目井然有序，您必须逐个轮询它们，而不是按原样打印
PriorityQueue

如果您正在寻找一个将被排序的结构，那么
树集
可能会更好，或者可能是一个普通的旧
数组列表
，在插入所有元素后显式地
排序。
啊，是的，我刚刚测试过它，它轮询正确。实际上，我正在尝试设计一个遵循HuffmanCoding的程序，我认为它首先需要一个优先级队列。不过，我相信它可以以多种不同的方式实现。啊，是的，我现在刚刚测试了它，它正确地进行了民意测验。实际上，我正在尝试设计一个遵循HuffmanCoding的程序，我认为它首先需要一个优先级队列。然而，我相信它可以以许多不同的方式实施。
public class PQNode implements Comparable<PQNode>{
    Character c;
    int freq;

    public PQNode(Character c, int freq) {
        this.c = c;
        this.freq = freq;
    }

    public String toString() {
        return "[c=" + c + ", freq=" + freq + "]";
    }

    public int compareTo(PQNode otherFreq) {
        return Integer.compare(this.freq, otherFreq.freq);
    }
}