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用於用斗跡耐於生產者-使用者隊列。