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://kswjz.com/article/ddsigeh.html