1. java 隊列
java類庫有Queue類，但是如果樓主想自己定義隊列的話，可以模仿C++指針定義隊列的方式。java和C#雖然沒有指針，但是它們的對象默認都是傳引用的，也就像指針傳遞地址一樣，呵呵。
2. java中的隊列都有哪些，有什麼區別
阻塞隊列、普通隊列，非阻塞隊列。
阻塞隊列與普通隊列的而區別在於，當隊列是空時，從隊列中獲取元素的操作會被阻塞，或則當隊列是滿的時，往隊列中增加元素會被阻塞，試圖從空的隊列中取元素的線程或從滿的隊列中添加元素的線程同樣會被阻塞。
3. java中的隊列都有哪些
常見的有：
有界隊列：
ArrayBlockingQueue
LinkedBlockingQuene
priorityBlockingQuene（具有優先順序的隊列）
無界隊列：
SynchronousQuene
4. 在java中，什麼是隊列
好比現實生活中排隊先進先出
5. 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介面。
6. 如何編寫一個JAVA的隊列類
importjava.util.*;
publicclassMyQueue<T>{
privateLinkedList<T>list=newLinkedList<T>();
publicvoidaddLast(Tv){
list.addLast(v);//隊尾插入
}
publicTgetFirst(){
returnlist.getFirst();//取得隊受元素
}
publicvoidremove(){
list.removeFirst();//移除隊首元素
}
//類似功能自己擴展下
publicstaticvoidmain(String[]args){
MyQueue<String>mq=newMyQueue<String>();
mq.addLast("helloworld");
mq.addLast("helloworld2");
System.out.println(mq.getFirst());
mq.remove();
System.out.println(mq.getFirst());
}
}
7. Java中的隊列都有哪些，有什麼區別
阻塞隊列與普通隊列的區別在於，當隊列是空的時，從隊列中獲取元素的操作將會被阻塞，或者當隊列是滿時，往隊列里添加元素的操作會被阻塞。試圖從空的阻塞隊列中獲取元素的線程將會被阻塞，直到其他的線程往空的隊列插入新的元素。同樣，試圖往已滿的阻塞隊列中添加新元素的線程同樣也會被阻塞，直到其他的線程使隊列重新變得空閑起來，如從隊列中移除一個或者多個元素，或者完全清空隊列.
從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);
}
}
8. 用java語言設計順序循環隊列類
代碼如下：
importjava.io.Serializable;
importjava.util.Arrays;
publicclassLoopQueue<T>implementsSerializable{
/**
*@FieldsserialVersionUID:TODO
*/
=-3670496550272478781L;
privateintDEFAULT_SIZE=10;
privateintcapacity;//保存數組的長度
privateObject[]elementData;//定義一個數組用於保存循環隊列的元素
privateintfront=0;//隊頭
privateintrear=0;//隊尾
//以默認數組長度創建空循環隊列
publicLoopQueue(){
capacity=DEFAULT_SIZE;
elementData=newObject[capacity];
}
//以一個初始化元素來創建循環隊列
publicLoopQueue(Telement){
this();
elementData[0]=element;
rear++;
}
/**
*以指定長度的數組來創建循環隊列
*
*@paramelement
*指定循環隊列中第一個元素
*@paraminitSize
*指定循環隊列底層數組的長度
*/
publicLoopQueue(Telement,intinitSize){
this.capacity=initSize;
elementData=newObject[capacity];
elementData[0]=element;
rear++;
}
//獲取循環隊列的大小
publicintsize(){
if(isEmpty()){
return0;
}
returnrear>front?rear-front:capacity-(front-rear);
}
//插入隊列
publicvoidadd(Telement){
if(rear==front&&elementData[front]!=null){
("隊列已滿的異常");
}
elementData[rear++]=element;
//如果rear已經到頭，那就轉頭
rear=rear==capacity?0:rear;
}
//移除隊列
publicTremove(){
if(isEmpty()){
("空隊列異常");
}
//保留隊列的rear端的元素的值
ToldValue=(T)elementData[front];
//釋放隊列的rear端的元素
elementData[front++]=null;
//如果front已經到頭，那就轉頭
front=front==capacity?0:front;
returnoldValue;
}
//返回隊列頂元素，但不刪除隊列頂元素
publicTelement(){
if(isEmpty()){
("空隊列異常");
}
return(T)elementData[front];
}
//判斷循環隊列是否為空隊列
publicbooleanisEmpty(){
//rear==front且rear處的元素為null
returnrear==front&&elementData[rear]==null;
}
//清空循環隊列
publicvoidclear(){
//將底層數組所有元素賦為null
Arrays.fill(elementData,null);
front=0;
rear=0;
}
publicStringtoString(){
if(isEmpty()){
return"[]";
}else{
//如果front<rear，有效元素就是front到rear之間的元素
if(front<rear){
StringBuildersb=newStringBuilder("[");
for(inti=front;i<rear;i++){
sb.append(elementData[i].toString()+",");
}
intlen=sb.length();
returnsb.delete(len-2,len).append("]").toString();
}
//如果front>=rear，有效元素為front->capacity之間、0->front之間的
else{
StringBuildersb=newStringBuilder("[");
for(inti=front;i<capacity;i++){
sb.append(elementData[i].toString()+",");
}
for(inti=0;i<rear;i++){
sb.append(elementData[i].toString()+",");
}
intlen=sb.length();
returnsb.delete(len-2,len).append("]").toString();
}
}
}
publicstaticvoidmain(String[]args){
LoopQueue<String>queue=newLoopQueue<String>("aaaa",3);
//添加兩個元素
queue.add("bbbb");
queue.add("cccc");
//此時隊列已滿
System.out.println(queue);
//刪除一個元素後，隊列可以再多加一個元素
queue.remove();
System.out.println("刪除一個元素後的隊列："+queue);
//再次添加一個元素，此時隊列又滿
queue.add("dddd");
System.out.println(queue);
System.out.println("隊列滿時的長度："+queue.size());
//刪除一個元素後，隊列可以再多加一個元素
queue.remove();
//再次加入一個元素，此時隊列又滿
queue.add("eeee");
System.out.println(queue);
}
}