java數組實現隊列

㈠ java 隊列

java類庫有Queue類，但是如果樓主想自己定義隊列的話，可以模仿C++指針定義隊列的方式。java和C#雖然沒有指針，但是它們的對象默認都是傳引用的，也就像指針傳遞地址一樣，呵呵。

㈡ 跪求用JAVA語言實現一個棧和一個隊列，數據元素為double型。。。具體在問題補充里

publicinterfaceMyStack<T>{
	/**
	*判斷棧是否為空
	*/
	booleanisEmpty();
	/**
	*清空棧
	*/
	voidclear();
	/**
	*棧的長度
	*/
	intlength();
	/**
	*數據入棧
	*/
	booleanpush(Tdata);
	/**
	*數據出棧
	*/
	Tpop();
}
publicclassMyArrayStack<T>implementsMyStack<T>{
	privateObject[]objs=newObject[16];
	privateintsize=0;

	@Override
	publicbooleanisEmpty(){
		returnsize==0;
	}

	@Override
	publicvoidclear(){
		//將數組中的數據置為null,方便GC進行回收
		for(inti=0;i<size;i++){
			objs[size]=null;
		}
		size=0;
	}

	@Override
	publicintlength(){
		returnsize;
	}

	@Override
	publicbooleanpush(Tdata){
		//判斷是否需要進行數組擴容
		if(size>=objs.length){
			resize();
		}
		objs[size++]=data;
		returntrue;
	}

	/**
	*數組擴容
	*/
	privatevoidresize(){
		Object[]temp=newObject[objs.length*3/2+1];
		for(inti=0;i<size;i++){
			temp[i]=objs[i];
			objs[i]=null;
		}
		objs=temp;
	}

	@SuppressWarnings("unchecked")
	@Override
	publicTpop(){
		if(size==0){
			returnnull;
		}
		return(T)objs[--size];
	}

	@Override
	publicStringtoString(){
		StringBuildersb=newStringBuilder();
		sb.append("MyArrayStack:[");
		for(inti=0;i<size;i++){
			sb.append(objs[i].toString());
			if(i!=size-1){
				sb.append(",");
			}
		}
		sb.append("]");
		returnsb.toString();
	}
}
//棧的鏈表實現
publicclassMyLinkedStack<T>implementsMyStack<T>{
	/**
	*棧頂指針
	*/
	privateNodetop;
	/**
	*棧的長度
	*/
	privateintsize;
	
	publicMyLinkedStack(){
		top=null;
		size=0;
	}
	
	@Override
	publicbooleanisEmpty(){
		returnsize==0;
	}
	
	@Override
	publicvoidclear(){
		top=null;
		size=0;
	}
	
	@Override
	publicintlength(){
		returnsize;
	}
	
	@Override
	publicbooleanpush(Tdata){
		Nodenode=newNode();
		node.data=data;
		node.pre=top;
		//改變棧頂指針
		top=node;
		size++;
		returntrue;
	}
	
	@Override
	publicTpop(){
		if(top!=null){
			Nodenode=top;
			//改變棧頂指針
			top=top.pre;
			size--;
			returnnode.data;
		}
		returnnull;
	}
	
	/**
	*將數據封裝成結點
	*/
	privatefinalclassNode{
		privateNodepre;
		privateTdata;
	}
}

㈢ 用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);
	}
}

㈣ queue java 是怎麼實現的

java中queue的使用
Queue介面與List、Set同一級別，都是繼承了Collection介面。LinkedList實現了Queue接 口。Queue介面窄化了對LinkedList的方法的訪問許可權（即在方法中的參數類型如果是Queue時，就完全只能訪問Queue介面所定義的方法 了，而不能直接訪問 LinkedList的非Queue的方法），以使得只有恰當的方法才可以使用。BlockingQueue 繼承了Queue介面。

隊列是一種數據結構．它有兩個基本操作：在隊列尾部加人一個元素，和從隊列頭部移除一個元素就是說，隊列以一種先進先出的方式管理數據，如果你試圖向一個 已經滿了的阻塞隊列中添加一個元素或者是從一個空的阻塞隊列中移除一個元索，將導致線程阻塞．在多線程進行合作時，阻塞隊列是很有用的工具。工作者線程可 以定期地把中間結果存到阻塞隊列中而其他工作者線線程把中間結果取出並在將來修改它們。隊列會自動平衡負載。如果第一個線程集運行得比第二個慢，則第二個 線程集在等待結果時就會阻塞。如果第一個線程集運行得快，那麼它將等待第二個線程集趕上來。下表顯示了jdk1.5中的阻塞隊列的操作：

add 增加一個元索 如果隊列已滿，則拋出一個IIIegaISlabEepeplian異常
remove 移除並返回隊列頭部的元素 如果隊列為空，則拋出一個NoSuchElementException異常
element 返回隊列頭部的元素 如果隊列為空，則拋出一個NoSuchElementException異常
offer 添加一個元素並返回true 如果隊列已滿，則返回false
poll 移除並返問隊列頭部的元素 如果隊列為空，則返回null
peek 返回隊列頭部的元素 如果隊列為空，則返回null
put 添加一個元素 如果隊列滿，則阻塞
take 移除並返回隊列頭部的元素 如果隊列為空，則阻塞

remove、element、offer 、poll、peek 其實是屬於Queue介面。

阻塞隊列的操作可以根據它們的響應方式分為以下三類：aad、removee和element操作在你試圖為一個已滿的隊列增加元素或從空隊列取得元素時 拋出異常。當然，在多線程程序中，隊列在任何時間都可能變成滿的或空的，所以你可能想使用offer、poll、peek方法。這些方法在無法完成任務時 只是給出一個出錯示而不會拋出異常。

注意：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方法在隊列空時阻塞。

java.ulil.concurrent包提供了阻塞隊列的4個變種。默認情況下，LinkedBlockingQueue的容量是沒有上限的（說的不準確，在不指定時容量為Integer.MAX_VALUE，不要然的話在put時怎麼會受阻呢），但是也可以選擇指定其最大容量，它是基於鏈表的隊列，此隊列按 FIFO（先進先出）排序元素。

ArrayBlockingQueue在構造時需要指定容量， 並可以選擇是否需要公平性，如果公平參數被設置true，等待時間最長的線程會優先得到處理（其實就是通過將ReentrantLock設置為true來 達到這種公平性的：即等待時間最長的線程會先操作）。通常，公平性會使你在性能上付出代價，只有在的確非常需要的時候再使用它。它是基於數組的阻塞循環隊 列，此隊列按 FIFO（先進先出）原則對元素進行排序。

PriorityBlockingQueue是一個帶優先順序的 隊列，而不是先進先出隊列。元素按優先順序順序被移除，該隊列也沒有上限（看了一下源碼，PriorityBlockingQueue是對 PriorityQueue的再次包裝，是基於堆數據結構的，而PriorityQueue是沒有容量限制的，與ArrayList一樣，所以在優先阻塞 隊列上put時是不會受阻的。雖然此隊列邏輯上是無界的，但是由於資源被耗盡，所以試圖執行添加操作可能會導致 OutOfMemoryError），但是如果隊列為空，那麼取元素的操作take就會阻塞，所以它的檢索操作take是受阻的。另外，往入該隊列中的元 素要具有比較能力。

最後，DelayQueue（基於PriorityQueue來實現的）是一個存放Delayed 元素的無界阻塞隊列，只有在延遲期滿時才能從中提取元素。該隊列的頭部是延遲期滿後保存時間最長的 Delayed 元素。如果延遲都還沒有期滿，則隊列沒有頭部，並且poll將返回null。當一個元素的 getDelay(TimeUnit.NANOSECONDS) 方法返回一個小於或等於零的值時，則出現期滿，poll就以移除這個元素了。此隊列不允許使用 null 元素。

㈤ java 有關ArrayList，可不可以用toString輸出的問題

首先，我們知道ArrayList是List的實現類，繼承於AbstractList，它是一個數組隊列，提供了相關的添加、刪除、修改、遍歷等功能。雖然它也是一個Object，但總體上來講，並沒有實現toString方法，所以其類來調用toString方法是不對的 (也就是說 不能ArrayList.toString)，但是既然是一個數組序列，而數組是可以調用toString方法，所以在不重寫的情況下，可以轉變為相應的數組，恰巧ArrayList實現的List中是有這個方法即list.toArray()。

如果你對基礎類型輸出，可以採用轉為相應的數組，進而可以調用Arrays.toString()方法輸出。

//比如
ArrayList<String>list=newArrayList<String>(Arrays.asList("BuenosAires","Córdoba","LaPlata"));
System.out.println(Arrays.toString(list.toArray()));

㈥ 高手請幫忙用java版的數據結構，設置3個隊列，實現入隊出隊。

import java.util.ArrayList;

/**
*
* @author 獄韜
*/
public class SnakeBody {
private int size=0; //隊列的長度
private int cursor=-1; //指針
private ArrayList<int[]> list=null; //存儲器

public SnakeBody() {
list=new ArrayList<int[]>(); //存儲器
}

//返回底部的數據
public int[] getLast(){
return list.get(list.size()-1);
}

//返回頂部的數據
public int[] getFirst(){
return list.get(0);
}

//壓入數據
public void put(int[] arry){
list.add(arry);
}

//刪除底部數據
public void removeLast(){
list.remove(list.size()-1);
}

//重置
public void reSet(){
list=new ArrayList<int[]>(); //存儲器
}

//刪除頂部數據
public void removeFirst(){
list.remove(0);
}

//返回數據長度
public int size(){
return list.size();
}

public static void main(String[] args) {
SnakeBody data = new SnakeBody();
for(int i=0;i<10;i++){
data.put(new int[]{0,i});
}
System.out.println(data.getFirst()[0]+"-------"+data.getFirst()[1]);
System.out.println(data.getLast()[0]+"-------"+data.getLast()[1]);
data.removeLast();
System.out.println(data.getFirst()[0]+"-------"+data.getFirst()[1]);
System.out.println(data.getLast()[0]+"-------"+data.getLast()[1]);
}
}