java隊列長度

1. java中怎麼設置隊列容量

通常，無需預先設置長度

2. JAVA有沒有可以限制容量大小的隊列

這個貌似沒有，但是你可以用別的集合，判斷當滿了的時候，刪除最舊的那一條，添加新的一條信息，這個數組和list都可以實現

3. java裡面，說到循環隊列的存儲空間為Q(1:35)包含什麼含義，如果front=1，front=

如果是正數就不用加35了，如果是負數才要加35

這一題明顯是個小陷阱，開始時候front=rear ，結束了還是front=rear 說明進來的和出去的一樣多啊，你看 如果這是進來一個元素rear就加1，變成rear=1（因為是1：35啊，就是說元素只能排在1-35之間，35排完了就滿了嗎，沒有 35排完了如果再進來元素就該排在1的位置上了。而不是36，這你得明白）

好了 進來一個rear加1 出去一個呢，front加1 就這樣進來出去，進來出去，到最後front和rear還是相等的，那不就說明進來和出去的一樣多嘛。 這樣一來最後的元素就和原來的元素一樣多了，明顯不是0就是35，因為要麼隊空（0個元素），要麼隊滿（35個元素）

%是求余數用的 10%3=1，就是這個意思 那個公式就是純粹數學公式，和編程，語言都沒關系。
這種題你畫一張圖最好理解了，當然短一點最好，弄個隊列長度為6的，自己動動手，出對入隊的畫畫就全明白了

4. 用java實現循環隊列

簡單寫了下，希望你能看明白

import java.util.ArrayList;

public class SeqQueue {

ArrayList<String> list;

public SeqQueue() {
list = new ArrayList<String>();
}

public String getFirst() {
if (!list.isEmpty()) {
String s = list.get(0);
list.remove(0);
return s;
}
return null;
}

public void insertLast(String s) {
list.add(s);
}

public static void main(String[] args) {
SeqQueue seq = new SeqQueue();
seq.insertLast("111");
seq.insertLast("222");
seq.insertLast("333");
System.out.println(seq.getFirst());
System.out.println(seq.getFirst());
System.out.println(seq.getFirst());
}

}

5. java阻塞隊列可以設置成無限大嗎

阻塞隊列是根據你分配給JVM內存大小來分配的，你分配給JVM內存越大，隊列則可存放的越多

6. 高手請幫忙用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]);
}
}

7. 數據結構：關於Java實現的一個隊列，對其中的擴容步驟有疑問答題的都是我爹

這確實有點奇葩，要麼修改resize方法，在進行復制的時候，先判斷一下front和rear的值，如果front不為0，說明進行過出隊列操作，再判斷rear與front的值：

if(front<rear){//fromfronttorear這樣就可以去除多餘的空位置，讓front從0開始}
if(front>rear){
//先復制後半段到新的數組，然後復制前半段到新數組的後面，這就保證0位置的就是隊列的頭
}

這樣的話，就可以理解為什麼resize之後將front置為0,。

不知道這樣的解釋對不對，我看完上面的代碼覺得就是這樣的。

8. java隊列設置為30000多麼

阻塞隊列是根據你分配給JVM內存大小來分配的，你分配給JVM內存越大，隊列則可存放的越多
「隊列」這個單詞是英國人說的「排」。在英國「排隊」的意思就是站到一排當中去。計算機科學中，隊列是一種數據結構，有點類似棧，
只是在隊列中第一個插入的數據項也會最先被移除，而在棧中，最後插入的數據項最先移除。

9. java編寫的隊列，網上給出的答案我有些迷惑！！！

你這個只是進隊 如果隊列滿了 只是會列印溢出，並不會對數組integerQueue有任何的影響，所以當 1 2 3 4 5的時候，進來的6並不會加入隊列裡面。如果出隊列你改變的並不是數組，而只是tail，

所以當 隊列是 1 2 3 4 5 的時候，出隊列了，只是讓tail改成3，但是整個數組的長度還是5，所以列印數組的時候還是 1 2 3 4 5
你可以在列印的時候 for(int i=0;i<integerQueue.length;i++)改for(inti=0;i<=tail;i++);

10. 用java語言設計一個先進先先出的隊列類

代碼僅供參考，如有問題，歡迎追問！

Basket：

importjava.util.concurrent.BlockingQueue;
importjava.util.concurrent.LinkedBlockingQueue;
/**
*定義裝蘋果的籃子
*
*@authorstone
*@version2013-05-21
*/
publicclassBasket{

//籃子，能夠容納Integer.MAX_VALUE個蘋果
BlockingQueue<Object>basket=newLinkedBlockingQueue<Object>(Integer.MAX_VALUE);

//生產蘋果，放入籃子
publicvoidproce(Objectobj)throwsInterruptedException{
	//put方法放入一個蘋果，若basket滿了，等到basket有位置
	basket.put(obj);
}

//消費蘋果，從籃子中取走
publicObjectconsume()throwsInterruptedException{
	//take方法取出一個蘋果，若basket為空，等到basket有蘋果為止(獲取並移除此隊列的頭部)
	returnbasket.take();
}

}

BaksetTest：

importorg.apache.log4j.Logger;
publicclassBaksetTest{

staticLoggerlogger=Logger.getLogger(BaksetTest.class);
staticBasketbasket=newBasket();

publicstaticvoidmain(String[]args)throwsException{
	try{
	Consumecon=newConsume(basket);
	Threadthread=newThread(con);
	thread.start();
	Integernum=0;
	while(true){//循環放入數據到隊列
		num++;
		basket.proce(num);
		Thread.sleep(1*1000);
		if(num>1000000)num=0;
	}
	}catch(Exceptione){
	logger.error("error:",e);
	}
}

}

//消費線程，用來消費隊列里堆積數據，此線程為阻塞狀態
{

Loggerlogger=Logger.getLogger(BaksetTest.class);
Basketbasket;

publicConsume(Basketbasket){
	this.basket=basket;
}

@Override
publicvoidrun(){
	try{
	while(true){//等待從隊列取出數據
		System.out.println("取出："+basket.consume());
	}
	}catch(Exceptione){
	logger.error("error:",e);
	}
}
}