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