javaqueue队列

⑴ 关于java队列的申明

我这里有一个测试代码，其中可以很明显的看到其中区别
public class QueueTest {
public static void main(String[] args) {
BlockingQueue<String> blockQueue = new LinkedBlockingQueue<String>();//new SynchronousQueue<String>()
class QueuePuter implements Runnable{
private BlockingQueue queue;
public QueuePuter(BlockingQueue queue) {
this.queue = queue;
}

public void run() {
try {
for(int i=0;i<10;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队列中最后一个元素

deque才是双端队列，

你可以用镇羡deque引用，然含判后御老拍E getLast();即可。

⑶ 在java中，List和队列Queue的作用有何不同(应用场景)

队列就是先进先出啊，对于数据只处理一次的比较有用。list一般可以反复读取。

其实队列可以用list实现，只是queue给了一个简单的实现类而已。

⑷ Java设计一个名为Queue的类用于存储整数。像栈一样，队列具有元素。在栈中，元素以“后进先出”的方式

参考代码和注释如下

简单测试了下,如果有问题接着在讨论

publicclassQueue{
	privateint[]elements;
	publicstaticfinalintDEFAULT_CAPACITY=8;//默认长度8
	privateintsize=0;

	publicQueue(){
		elements=newint[DEFAULT_CAPACITY];
	}

	publicQueue(intcapacity){
		elements=newint[capacity];

	}

	publicvoidenqueue(intv){
		if(size>=elements.length){//数组扩容
			int[]temp=newint[elements.length*2];
			System.array(elements,0,temp,0,elements.length);
			elements=temp;
		}
		elements[size++]=v;

	}

	publicintdequeue(){//先进先出
		if(empty()){
			thrownewRuntimeException("异常");
		}

		intx=elements[0];//先把第一个元素保存出来

		//左移一位
		//int[]temp=newint[elements.length];
		//System.array(elements,1,temp,0,elements.length-1);
		//elements=temp;

		//左移一迟老位
		for(inti=0;i<elements.length-1;i++){
			elements[i]=elements[i+1];
		}
		elements[elements.length-1]=0;//外面一般访歼斗问不了elements后面的元素可以不用归零,但是归零了感觉舒服点
		size--;
		returnx;
	}

	publicboolean氏旦磨empty(){
		returnsize==0;
	}

	publicintgetSize(){
		returnsize;
	}
}

输出

⑸ java对象从queue队列中出队，对象的一个参数变为null

你说的是双向队列Deque<E>吧穗梁，队列根本没有offerLast方法。

你这上下文代码也没有，我只能猜盯仔测着试了一下：

确实是para1、para2先后出队，而且也没啥null的情况发生啊。

你检查是不是入队之前那个List就有问题，它本来就是猜则运null？可以在调试模式下跟踪一下队列的情况。

另外纠正一下，啥叫对象的参数啊，我一下都没明白过来，请叫人家成员变量。

⑹ java中queue的使用方法

java中的queue类是队列数据结构管理类。在它里边的元素可以按照添加它们的相慧握同顺序被移除。
队列通常（但并非一定）以 FIFO（先进先出）的方式排序各个元素。不过优先级队列和 LIFO 队列（或堆栈）例外，前者根据提供的比较器或元素的自然顺序对元素进行排序，后者稿岁按 LIFO（后进先出）的方式对元素进行排序。无论使用哪种排序方式，队列的头都是调用remove()或poll()所移除的元素。在 FIFO 队列中，所有的新元素都插入队列的末尾。其他种类的队列可能使用不同的元素放置规则。每个Queue实现必须指定其顺序属性。

offer 添加一个元素并返回true 如果队列已满，则返回false
poll 移除并返问队列头部的元素 如果队列为空，则返回null
peek 返回队列头部前敬庆的元素 如果队列为空，则返回null
put 添加一个元素 如果队列满，则阻塞
take 移除并返回队列头部的元素 如果队列为空，则阻塞
element 返回队列头部的元素 如果队列为空，则抛出一个NoSuchElementException异常

add 增加一个元索 如果队列已满，则抛出一个IIIegaISlabEepeplian异常
remove 移除并返回队列头部的元素 如果队列为空，则抛出一个
NoSuchElementException异常

注意：poll和peek方法出错进返回null。因此，向队列中插入null值是不合法的。

还有带超时的offer和poll方法重载，例如，下面的调用：
boolean success = q.offer(x,100,TimeUnit.MILLISECONDS);
尝试在100毫秒内向队列尾部插入一个元素。如果成功，立即返回true；否则，当到达超时进，返回false。同样地，调用：
Object head = q.poll(100, TimeUnit.MILLISECONDS);
如果在100毫秒内成功地移除了队列头元素，则立即返回头元素；否则在到达超时时，返回null。
阻塞操作有put和take。put方法在队列满时阻塞，take方法在队列空时阻塞。

Queue接口与List、Set同一级别，都是继承了Collection接口。LinkedList实现了Queue接 口。Queue接口窄化了对LinkedList的方法的访问权限（即在方法中的参数类型如果是Queue时，就完全只能访问Queue接口所定义的方法 了，而不能直接访问 LinkedList的非Queue的方法），以使得只有恰当的方法才可以使用。BlockingQueue 继承了Queue接口。

⑺ Java中Queue和BlockingQueue的区别

阻塞队列与普通队列的区别在于，当队列是空的时，从队列中获取元素的操作将李虚会答谨被阻塞，或者当队列是满时，往队列里添加元素的操作会被阻塞。试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其他的线程往空的队列插入新的元素。同样，试图往已满的阻塞队列中添加新元哪举燃素的线程同样也会被阻塞，直到其他的线程使队列重新变得空闲起来，如从队列中移除一个或者多个元素，或者完全清空队列.
从5.0开始，JDK在java.util.concurrent包里提供了阻塞队列的官方实现。尽管JDK中已经包含了阻塞队列的官方实现，但是熟悉其背后的原理还是很有帮助的。一下是阻塞队列的实现:
public class BlockingQueue {

private List queue = new LinkedList();

private int limit = 10;

public BlockingQueue(int limit){

this.limit = limit;

}

public synchronized void enqueue(Object item)

throws InterruptedException {

while(this.queue.size() == this.limit) {

wait();

}

if(this.queue.size() == 0) {

notifyAll();

}

this.queue.add(item);

}

public synchronized Object dequeue()

throws InterruptedException{

while(this.queue.size() == 0){

wait();

}

if(this.queue.size() == this.limit){

notifyAll();

}

return this.queue.remove(0);

}

}

⑻ java中创建队列Queue的问题

因为queue是接口，不能new 接口，应该new接口实现类，你看jdk文档，搜索queue，如图：

看见下面有一大堆实现queue的类，选一个就行，针对队列的，你可以选LinkedBlockingQueue,AbstrctQueue,ArrayDeque

⑼ java编程：定义一个表示队列的泛型类Queue,分别对String对象和Integer对象执行入队列和出队列操作。

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class Queue<T>{
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!=null&&q.size()>0){
list=new ArrayList();
list.add(q.poll());
}
return list;
}public static void main(String []args){
Queue<Integer>q=new Queue<Integer>(1);
q.offer();
List list=q.poll();
System.out.println("出队列的元素为："并滚升+list.get(0));
Queue<String>qq=new Queue<String>("1");
q.offer();
List list2=q.poll();
System.out.println("出队列的绝老元备郑素为："+list2.get(0));

}
// TODO Auto-generated method stub

}

⑽ java中Queue和BlockingQueue的区别

1.BlockingQueue:支持两个附加操作的 Queue，这空春两个操作是：检索元素时等待队列变为非空，以及存储元素时等待空间变得可用。
2.BlockingQueue 不接受 null 元素。
3.BlockingQueue 可以是限定容量的。
4.BlockingQueue 实现是线程安全的。Queue不是线程安全的。因此州辩可以将Blockingqueue用于用斗迹耐于生产者-使用者队列。