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