Java PriorityQueue.toString元素顺序错误

我试图在java中使用优先级最低的节点创建优先级队列。然而，我的比较器不工作，输出非常奇怪。我相信我需要改变我的比较仪，但我不知道如何改变它。 这是我的密码：

public class HuffmanComparator implements Comparator<TreeNodeHuffman> {
    public int compare(TreeNodeHuffman p1, TreeNodeHuffman p2) {
        if (p1.frequency < p2.frequency) return -1;
        if (p1.frequency > p2.frequency) return 1;
        return 0;
    }    
}

public class TreeNodeHuffman {
public static void main(String[] args) {    
    HuffmanComparator compare = new HuffmanComparator();
    TreeNodeHuffman e = new TreeNodeHuffman('e', 12702);
    TreeNodeHuffman t = new TreeNodeHuffman('t', 9056);
    TreeNodeHuffman a = new TreeNodeHuffman('a', 8167);
    TreeNodeHuffman o = new TreeNodeHuffman('o', 7507);
    TreeNodeHuffman i = new TreeNodeHuffman('i', 6966);
    TreeNodeHuffman n = new TreeNodeHuffman('a', 6749);
    TreeNodeHuffman s = new TreeNodeHuffman('s', 6327);
    TreeNodeHuffman h = new TreeNodeHuffman('h', 6094);
    TreeNodeHuffman r = new TreeNodeHuffman('r', 5987);
    TreeNodeHuffman d = new TreeNodeHuffman('d', 4253);
    TreeNodeHuffman l = new TreeNodeHuffman('l', 4025);
    TreeNodeHuffman c = new TreeNodeHuffman('c', 2782);
    TreeNodeHuffman u = new TreeNodeHuffman('u', 2758);
    TreeNodeHuffman m = new TreeNodeHuffman('m', 2406);
    TreeNodeHuffman w = new TreeNodeHuffman('w', 2360);
    TreeNodeHuffman f = new TreeNodeHuffman('f', 2228);
    TreeNodeHuffman g = new TreeNodeHuffman('g', 2015);
    TreeNodeHuffman y = new TreeNodeHuffman('y', 1974);
    TreeNodeHuffman p = new TreeNodeHuffman('p', 1929);
    TreeNodeHuffman b = new TreeNodeHuffman('b', 1492);
    TreeNodeHuffman v = new TreeNodeHuffman('v', 978);
    TreeNodeHuffman k = new TreeNodeHuffman('k', 772);
    TreeNodeHuffman j = new TreeNodeHuffman('j', 153);
    TreeNodeHuffman x = new TreeNodeHuffman('x', 150);
    TreeNodeHuffman q = new TreeNodeHuffman('q', 95);
    TreeNodeHuffman z = new TreeNodeHuffman('z', 74);
    PriorityQueue<TreeNodeHuffman> queue = new PriorityQueue<TreeNodeHuffman>(26, compare);
    queue.add(e);
    queue.add(t);
    queue.add(a);
    queue.add(o);
    queue.add(i);
    queue.add(n);
    queue.add(s);
    queue.add(h);
    queue.add(r);
    queue.add(d);
    queue.add(l);
    queue.add(c);
    queue.add(u);
    queue.add(m);
    queue.add(w);
    queue.add(f);
    queue.add(g);
    queue.add(y);
    queue.add(p);
    queue.add(b);
    queue.add(v);
    queue.add(k);
    queue.add(j);
    queue.add(x);
    queue.add(q);
    queue.add(z);
    System.out.println(queue);
}
}

公共类HuffmanComparator实现Comparator{
公共整数比较（TreeNodeHuffman p1，TreeNodeHuffman p2）{
if（p1.frequencyp2.频率）返回1；
返回0；
}    
}
公共级TreeNodeHuffman{
公共静态void main（字符串[]args）{
HuffmanComparator compare=新的HuffmanComparator（）；
TreeNodeHuffman e=新的TreeNodeHuffman（'e'，12702）；
TreeNodeHuffman t=新的TreeNodeHuffman（'t'，9056）；
TreeNodeHuffman a=新的TreeNodeHuffman（'a'，8167）；
TreeNodeHuffman o=新的TreeNodeHuffman（'o'，7507）；
TreeNodeHuffman i=新的TreeNodeHuffman（'i'，6966）；
TreeNodeHuffman n=新的TreeNodeHuffman（'a'，6749）；
TreeNodeHuffman s=新的TreeNodeHuffman（'s'，6327）；
TreeNodeHuffman h=新的TreeNodeHuffman（'h'，6094）；
TreeNodeHuffman r=新的TreeNodeHuffman（'r'，5987）；
TreeNodeHuffman d=新的TreeNodeHuffman（'d'，4253）；
TreeNodeHuffman l=新的TreeNodeHuffman（'l'，4025）；
TreeNodeHuffman c=新的TreeNodeHuffman（'c'，2782）；
TreeNodeHuffman u=新的TreeNodeHuffman（'u'，2758）；
TreeNodeHuffman m=新的TreeNodeHuffman（'m'，2406）；
TreeNodeHuffman w=新的TreeNodeHuffman（'w'，2360）；
TreeNodeHuffman f=新的TreeNodeHuffman（'f'，2228）；
TreeNodeHuffman g=新的TreeNodeHuffman（'g'，2015年）；
TreeNodeHuffman y=新的TreeNodeHuffman（'y'，1974年）；
TreeNodeHuffman p=新的TreeNodeHuffman（'p'，1929年）；
TreeNodeHuffman b=新的TreeNodeHuffman（'b'，1492）；
TreeNodeHuffman v=新的TreeNodeHuffman（'v'，978）；
TreeNodeHuffman k=新的TreeNodeHuffman（'k'，772）；
TreeNodeHuffman j=新的TreeNodeHuffman（'j'，153）；
TreeNodeHuffman x=新的TreeNodeHuffman（'x'，150）；
TreeNodeHuffman q=新的TreeNodeHuffman（'q'，95）；
TreeNodeHuffman z=新的TreeNodeHuffman（'z'，74）；
PriorityQueue=新的PriorityQueue（26，比较）；
添加（e）；
添加（t）；
加入（a）；
添加（o）；
加入（i）；
添加（n）；
队列。添加；
添加（h）；
添加（r）；
添加（d）；
添加（l）；
添加（c）；
添加（u）；
添加（m）；
添加（w）；
添加（f）；
添加（g）；
添加（y）；
添加（p）；
加入（b）；
添加（v）；
添加（k）；
添加（j）；
添加（x）；
添加（q）；
添加（z）；
System.out.println（队列）；
}
}

结果如下： [z，k，q，g，v，x，u，d，f，y，b，m，j，i，c，e，s，o，w，a，r，h，p，t，l，a]。 但是，输出应为[z、q、x、j、k、v、b……]。

---

提前谢谢

您希望较低的频率变高，因此：

  public int compare(TreeNodeHuffman p1, TreeNodeHuffman p2) {
          if (p1.frequency < p2.frequency) return 1;
          if (p1.frequency > p2.frequency) return -1;
          return 0;
      }    
   }

public int比较（TreeNodeHuffman p1，TreeNodeHuffman p2）{
如果（p1.频率p2.频率）返回-1；
返回0；
}    
}

如果要测试它，请将其发送到单个线程池，并查看正在处理的作业的顺序，而不是字符串或迭代器。正如doc所说：

返回此队列中元素的迭代器。迭代器不会以任何特定顺序返回元素

---

可以查看快速单线程池以测试此功能。

您需要逐个轮询

优先级队列中的项目
toString
不会这样做

因此，不要使用
System.out.println（队列）执行以下操作：

while(!queue.isEmpty()) {
   System.out.println(queue.poll());
}

原因是，
PriorityQueue
从未在内部完全排序，请查阅堆的工作原理以了解更多详细信息。来自它的轮询项在调用期间修复了堆，因此它应该按排序的顺序输出元素。
System.out.println（queue）
正在打印未排序的队列。如果要打印队列真实顺序，请遵循以下代码，该代码使用轮询从队列顶部到底部获取元素：

TreeNodeHuffman tn = null;
    do{
        tn = queue.poll();
        if(tn!=null){
            System.out.print(tn.key+",");
        }
    }while(tn != null);

您将看到预期的输出：

z、 q，x，j，k，v，b，p，y，g，f，w，m，u，c，l，d，r，h，s，a，i，o，a，t，e

@托马斯回答工作

我的方法是在不清空队列的情况下产生相同的结果。因此，我在
PriorityQueue
上创建了一个包装器，并为它实现了
next（）
和
hasNext（）
。另外，为了精确模拟优先级队列行为，
通过PriorityQueue对象扩展AbstractQueue
和委托调用
提供
、
查看
、
轮询
和
大小
等方法

priorityQueueObject.methodName()

免责声明：这需要将整个队列复制到列表中并对其进行排序

public class MyPriorityQueue<E extends Comparable<T>, T> extends AbstractQueue<E> {
    Integer arrOfInts[] = { 11, 7, 15, 10, 2, 1, 4, 5, 7, 2, 18, 1, 19};
    PriorityQueue<E> pq = new PriorityQueue<>();

    public static void main(String[] args) {
        MyPriorityQueue mpq = new MyPriorityQueue<>();
        mpq.addAll(Arrays.asList(arrOfInts));

        //Using iterator
        Iterator it = mpq.iterator();
        System.out.println("The internal priority queue:"  + mpq.pq);
        System.out.println("Using Iterator:");
        while(it.hasNext()) {
            System.out.print(it.next() + ", ");
        }

        System.out.println("\nUsing simple system out println:");
        System.out.println(mpq);

        System.out.println("Using foreach: ");
        for(Object o : mpq) {
            System.out.print(o + ", ");
        }
    }

    @Override
    public boolean offer(E arg0) {
        return pq.offer(arg0);
    }

    @Override
    public E peek() {
        return pq.peek();
    }

    @Override
    public E poll() {
        return pq.poll();
    }

    @Override
    public Iterator<E> iterator() {
        ArrayList<E> list = new ArrayList(Arrays.asList(pq.toArray()));
        Collections.sort(list, null);
        return new Iterator<E>() {
            @Override
            public boolean hasNext() {
                return !list.isEmpty();
            }

            @Override
            public E next() {
                assert (hasNext());
                return list.remove(0);
            }
        };
    }

    @Override
    public int size() {
        return pq.size();
    }
}

@LuiggiMendoza:
toString
使用迭代器显示所有对象。@LuiggiMendoza从AbstractCollection的代码中看到，toString使用迭代器，因此它应该按遍历顺序打印元素。这是PriorityQueue（至少在Java 6中）使用的toString的实现。文档中说：
方法迭代器（）中提供的迭代器不保证以任何特定顺序遍历优先级队列的元素。
@Eran迭代器无法做到这一点，它是一个堆。如果不实际修改集合，则无法对其进行排序。如果需要一个结构，该结构将按顺序返回元素，而不改变结构，请使用
树集
，而不是
优先级队列
。
The internal priority queue:[1, 2, 1, 7, 5, 2, 4, 11, 7, 10, 18, 15, 19]
Using Iterator:
1, 1, 2, 2, 4, 5, 7, 7, 10, 11, 15, 18, 19, 
Using simple system out println:
[1, 1, 2, 2, 4, 5, 7, 7, 10, 11, 15, 18, 19]
Using foreach: 
1, 1, 2, 2, 4, 5, 7, 7, 10, 11, 15, 18, 19,