Java ！ 帮我定义一个优先队列（priority queue）
PriorityQueueString queue= new PriorityQueueString();
成都创新互联坚持“要么做到，要么别承诺”的工作理念，服务领域包括：成都网站制作、成都做网站、企业官网、英文网站、手机端网站、网站推广等服务，满足客户于互联网时代的辉南网站设计、移动媒体设计的需求，帮助企业找到有效的互联网解决方案。努力成为您成熟可靠的网络建设合作伙伴！
//定义优先队列，此处用了泛型.下面是添加元素：
queue.add("1");
queue.add("2");
queue.add("3");
用java语言设计一个先进先先出的队列类
代码仅供参考，如有问题，欢迎追问！
Basket：
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
/**
* 定义装苹果的篮子
*
* @author stone
* @version 2013-05-21
*/
public class Basket {
// 篮子，能够容纳Integer.MAX_VALUE个苹果
BlockingQueueObject basket = new LinkedBlockingQueueObject(Integer.MAX_VALUE);
// 生产苹果，放入篮子
public void produce(Object obj) throws InterruptedException {
// put方法放入一个苹果，若basket满了，等到basket有位置
basket.put(obj);
}
// 消费苹果，从篮子中取走
public Object consume() throws InterruptedException {
// take方法取出一个苹果，若basket为空，等到basket有苹果为止(获取并移除此队列的头部)
return basket.take();
}
}
BaksetTest：
import org.apache.log4j.Logger;
public class BaksetTest {
static Logger logger = Logger.getLogger(BaksetTest.class);
static Basket basket = new Basket();
public static void main(String[] args) throws Exception {
try{
Consume con = new Consume(basket);
Thread thread = new Thread(con);
thread.start();
Integer num = 0;
while(true){//循环放入数据到队列
num++;
basket.produce(num);
Thread.sleep(1*1000);
if(num1000000) num =0;
}
} catch( Exception e ){
logger.error("error : ", e);
}
}
}
//消费线程，用来消费队列里堆积数据，此线程为阻塞状态
class Consume implements Runnable {
Logger logger = Logger.getLogger(BaksetTest.class);
Basket basket;
public Consume (Basket basket){
this.basket = basket;
}
@Override
public void run() {
try{
while(true){//等待从队列取出数据
System.out.println("取出：" + basket.consume());
}
} catch ( Exception e ){
logger.error("error : ", e);
}
}
}
关于JAVA队列的申明
我这里有一个测试代码，其中可以很明显的看到其中区别
public class QueueTest {
public static void main(String[] args) {
BlockingQueueString blockQueue = new LinkedBlockingQueueString();//new SynchronousQueueString()
class QueuePuter implements Runnable{
private BlockingQueue queue;
public QueuePuter(BlockingQueue queue) {
this.queue = queue;
}
public void run() {
try {
for(int i=0;i10;i++){
queue.put("Item "+i);
System.out.println("Put Item "+i);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class QueueTaker implements Runnable{
private BlockingQueue queue;
public QueueTaker(BlockingQueue queue) {
this.queue = queue;
}
public void run() {
try {
Object obj = null;
while((obj = queue.take())!=null){
System.out.println("Take "+obj);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
new Thread(new QueueTaker(blockQueue)).start();
//如果是 SynchronousQueue 把这行注释掉 程序会阻塞，说明如果没有线程执行take()操作则所有线程的put()操作都会被阻塞。
//如果是 LinkedBlockingQueue 把这行注释掉 程序会正常退出，说明就算没有take()操作的线程，所有线程的put()操作也可以把所有数据写入管道,而且管道容量可以不限。
new Thread(new QueuePuter(blockQueue)).start();
//如果是 SynchronousQueue 把这行注释掉 程序会阻塞, 说明如果没有线程执行put()操作则所有线程take()都会被阻塞。而且take()操作执行了几次，put()操作也只能执行几次，说明管道是没有容量的，同时只能操作一个元素。
//如果是 LinkedBlockingQueue 把这行注释掉 程序会阻塞, 说明如果管道是空的并且没有线程执行put()操作则所有线程take()都会被阻塞。
}
}
java编程：定义一个表示队列的泛型类Queue,分别对String对象和Integer对象执行入队列和出队列操作。
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
public class QueueT{
private static LinkedList q;
private T t;
private T getT(T t){
return t;
}
public void setT(T t){
this.t=t;
}
public Queue(T t){
this.t=t;
}
private void offer(){
if(q!=null){
q.offer(t);
}
else{
q=new LinkedList();
q.offer(t);
}
}
public List poll(){
List list=null;
while(q!=nullq.size()0){
list=new ArrayList();
list.add(q.poll());
}
return list;
}public static void main(String []args){
QueueIntegerq=new QueueInteger(1);
q.offer();
List list=q.poll();
System.out.println("出队列的元素为："+list.get(0));
QueueStringqq=new QueueString("1");
q.offer();
List list2=q.poll();
System.out.println("出队列的元素为："+list2.get(0));
}
// TODO Auto-generated method stub
}
名称栏目：java队列的定义代码 java队列的实现原理
本文来源：
http://cdkjz.cn/article/ddsigeh.html
