Java 优先级队列未维护队列属性

我已建立优先级阻止队列。插入操作根据优先级正确完成。当我删除队列头时，队列的最后一个元素将成为队列头，过程将重复。 假设我在队列中插入了123456789

First deleted : 1;  queue elements :92345678  
Second deleted:  9; queue elements :8234567  

等等

我需要实现队列属性，它没有被维护

i、 e 首次删除：1个队列元素：23456789
第二次删除：2个队列元素：3456789

package com.block.ui;

import java.util.Iterator;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;

public class PriorityBlockQueSamplActivity extends Activity {
/** Called when the activity is first created. */

EditText et;
EditText et2;
Button b1;
Button b2;

Controller c ;
@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);

    et=(EditText)findViewById(R.id.editText1);
    et2=(EditText)findViewById(R.id.editText2);
    b1 =(Button)findViewById(R.id.button1);
    b2 =(Button)findViewById(R.id.button2);
    c= new Controller();


    Message m = new Message();
    m.mPriority=1;
    m.Subject="1";
    c.insert(m);

    Message n = new Message();
    n.mPriority=1;
    n.Subject="2";
    c.insert(n);
    Message p = new Message();
    p.mPriority=1;
    p.Subject="3";
    c.insert(p);

    Message q = new Message();
    q.mPriority=1;
    q.Subject="4";
    c.insert(q);


    b1.setOnClickListener(new OnClickListener() {

        @Override
        public void onClick(View v) {

            Iterator<Message> iter = c.getQueue().iterator();
            while(iter.hasNext()){
                Message m =iter.next();
                Log.i("MESSAGE", "Element "+m.Subject+" priority :"+m.mPriority);
            }

        }
    });
    b2.setOnClickListener(new  OnClickListener() {

        @Override
        public void onClick(View v) {
            Message m=c.getMessage();
            c.delete(m);

        }
    });
}

package com.block.ui；
导入java.util.Iterator；
导入android.app.Activity；
导入android.os.Bundle；
导入android.util.Log；
导入android.view.view；
导入android.view.view.OnClickListener；
导入android.widget.Button；
导入android.widget.EditText；
公共类优先级BlockQuesSamplactivity扩展活动{
/**在首次创建活动时调用*/
编辑文本；
编辑文本et2；
按钮b1；
按钮b2；
控制器c；
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.main）；
et=（EditText）findViewById（R.id.editText1）；
et2=（EditText）findViewById（R.id.editText2）；
b1=（按钮）findViewById（R.id.button1）；
b2=（按钮）findViewById（R.id.button2）；
c=新控制器（）；
消息m=新消息（）；
m、 m优先级=1；
m、 主题=“1”；
c、 插入（m）；
消息n=新消息（）；
n、 m优先级=1；
n、 主题=“2”；
c、 插入（n）；
消息p=新消息（）；
p、 m优先级=1；
p、 主题=“3”；
c、 插入（p）；
消息q=新消息（）；
q、 m优先级=1；
q、 主题=“4”；
c、 插入（q）；
b1.setOnClickListener（新的OnClickListener（）{
@凌驾
公共void onClick（视图v）{
迭代器iter=c.getQueue（）.Iterator（）；
while（iter.hasNext（））{
消息m=iter.next（）；
Log.i（“消息”、“元素”+m.Subject+“优先级”+m.mPriority）；
}
}
});
b2.setOnClickListener（新的OnClickListener（）{
@凌驾
公共void onClick（视图v）{
Message m=c.getMessage（）；
c、 删除（m）；
}
});
}

}

还有一节课

 `public class Controller {

private int queueSize=300;
Comparator<Message> comparator = new PriorityComaparator();
PriorityBlockingQueue<Message> qu = new PriorityBlockingQueue<Message>(queueSize,comparator);

            public Controller() {

}

public void insert(Message msg) {

    boolean status = qu.add(msg);
    if (status)
        log("Added successfully " + msg.Subject + " priority "
                + msg.mPriority + " size :" + qu.size());
    else
        log("Failed to add " + msg.Subject + " with priority "
                + msg.mPriority);

}

public void delete(Message msg) {
    if (qu.contains(msg)) {
        boolean status = qu.remove(msg);
        if (status)
            log("deleted successfully " + msg.Subject + " priority " + msg.mPriority
                    + " size :" + qu.size());
        else
            log("Failed to delete " + msg.Subject + " with priority "+ msg.mPriority);
    }
}

public Message getMessage() {
    return qu.peek(); 
}

public PriorityBlockingQueue<Message> getQueue(){
    return qu;
}
void log(String msg) {
    Log.i("QUEUE", msg);
}

class PriorityComaparator implements Comparator<Message> {

    @Override
    public int compare(Message m, Message n) {
        int y = ((Message) m).mPriority; // 1 -highest 3-least
        int z = ((Message) n).mPriority;


        if (y < z) {
            return -1;
        }
        if (y > z) {
            return 1;
            }
            return 0;
            }

        }

}`

`公共类控制器{
私有整数队列大小=300；
Comparator Comparator=新的PriorityComparator（）；
PriorityBlockingQueue qu=新的PriorityBlockingQueue（队列大小，比较器）；
公共控制员（）{
}
公共作废插入（消息消息消息）{
布尔状态=qu.add（msg）；
如果（状态）
日志（“添加成功”+消息主题+“优先级”
+msg.mPriority+“大小：”+qu.size（））；
其他的
日志（“添加带有优先级的“+msg.Subject+”失败”
+味精优先）；
}
公共作废删除（消息消息消息）{
如果（qu.contains（msg））{
布尔状态=qu.remove（msg）；
如果（状态）
日志（“删除成功”+msg.Subject+“优先级”+msg.mPriority
+“大小：”+qu.size（））；
其他的
日志（“未能删除优先级为“+msg.mPriority”的“+msg.Subject+”）；
}
}
公共消息getMessage（）{
返回qu.peek（）；
}
public PriorityBlockingQueue getQueue（）{
还曲；
}
无效日志（字符串消息）{
Log.i（“队列”，msg）；
}
类PriorityComparator实现比较器{
@凌驾
公共整数比较（消息m、消息n）{
int y=（（消息）m）.mPriority；//1-最高3-最低
intz=（（消息）n）.m优先级；
if（yz）{
返回1；
}
返回0；
}
}
}`

如果您使用的优先级队列是您的个人实现，则尝试使用堆数据结构

正如维基页面所说：

堆是一种称为优先级队列的抽象数据类型的高效实现

这里是链接到

---

请记住，在Java中，您不需要实现它，您可以使用标准类，或者如果您需要它在多线程程序中工作。

如果像在示例中一样，所有插入的元素都具有相同的优先级，则检索顺序没有很好地定义。从（从中派生相同的排序规则）：

此队列的头是相对于指定顺序的最小元素。如果多个元素以最小值绑定，则头部是其中一个元素--任意断开绑定。

---

（强调添加）

为什么要将最后一个元素移动到队列的头部？这是我在删除队列中的元素时看到的，我们可能需要看到一些代码。@Damien_异类代码更新了吗？我不使用priorityBlockingQueue吗？priorityBlockingQueue或PriorityQueue除了同步之外是相同的。。我的问题是，从队列中删除元素的顺序与我们通常期望的@dash1eYes不符。如果需要多个线程之间的同步，您可以使用PriorityBlockingQueue。您是说Java PriorityQueue在删除项目时会出问题吗？在队列中，当保留相同优先级的消息时，删除顺序就像后进先出一样，队列中不应该是这种情况…因此，在这种情况下，我可以获得正常队列属性@meher-您可以将enqueuedTime添加到

消息

，在插入过程中设置它，并在比较器中使用它来断开具有相同优先级的两条消息之间的联系。（或者，如果您无法直接修改

消息

，请引入包装器类）。@Damien_不信者的第一点是，引入包装器类，如何可能，您能清楚地解释我吗。。