java中的队列用什么实现？

java中的队列用什么实现？

[url]http://liuqing-2010-07.iteye.com/blog/1330830[/url]
这篇博客中用到了java中的队列可以去看看。

java中的队列：LinkedList
其他队列可以参照：
LinkedBlockingQueue 不是 LinkedBlockingDeque
ArrayBlockingQueue
LinkedBlockingQueue FIFO队列
ConcurrentLinkedQueue 基于链接节点的无界线程安全队列
PriorityBlockingQueue 带优先级的无界阻塞队列

直接去看代码就可以了。
好好看看队列接口：Queue

[code="java"]java中的队列用什么实现？ 单向队列:
import javakit.util.*;
import java.util.*;

public class Queue{
private LinkedList list = new LinkedList();
public void put(Object v){list.addFirst(v);}
public Object get(){return list.removeLast();}
public boolean isEmpty(){return list.isEmpty();}
}
双向队列:
import java.util.*;
class DQueue implements Collection{
private LinkedList lists ;
public DQueue(){
lists = new LinkedList();
}
public void put_front(Object v){
lists.addFirst(v);
}
public void put_back(Object v){
lists.addLast(v);
}
public Object get_front(){
return lists.removeFirst();
}
public Object get_Back(){
return lists.removeLast();
}
public boolean isEmpty(){
return lists.isEmpty();
}
public int size(){
return lists.size();
}
public boolean contains(Object o) {
return lists.contains(o);
}
public Iterator iterator() {
return lists.iterator();
}
public Object[] toArray() {
return lists.toArray();
}
public Object[] toArray(Object a[]) {
return lists.toArray(a);
}
public boolean add(Object o) {
lists.addLast(o);
return true;
}
public boolean remove(Object o) {
return lists.remove(o);
}
public boolean containsAll(Collection c) {
return lists.containsAll(c);
}
public boolean addAll(Collection c) {
return lists.addAll(c);
}
public boolean removeAll(Collection c) {
return lists.removeAll(c);
}
public boolean retainAll(Collection c) {
return lists.retainAll(c);
}
public void clear() { lists.clear(); }
}
[/code]

[code="java"]整套实现：

class Element{
int id;
String name;
Element(int a,String n){
id=a;name=n;
}
}

class SeqQueue{
int first,last,maxsize;
Element queue[];
SeqQueue(int i){
maxsize=i;
first=last=-1;
queue=new Element[i];
}

public void clear(){//置空
    first=last=-1;
}

public boolean isEmpty(){//判空
    if(first==-1)return true;
    else return false;
}

public Element getFirst(){//取队列头元素
    if(first==-1)return null;
    else return queue[first+1];
}

public boolean isFull(){//判满
    if((last+1)%maxsize==first)return true;
    else return false;
}

public boolean enQueue(Element e){//入队
    if(this.isFull())return false;
    if(this.isEmpty())
        first=last=0;
    else
        last=(last+1)%maxsize;
    queue[last]=e;
    return true;
}

public Element deQueue(){//出队
    Element t=queue[first];
    if(this.isEmpty())return null;
    if(first==last){
        queue[first]=null;
        this.clear();
        return t;
    }
    queue[first]=null;
    first=(first+1)%maxsize;
    return t;
}

public int getLength(){//队列长度
    if(last>=first)return last-first+1;
    else return maxsize-(first-last)+1;
}

public void display(){//打印所有元素
    int i,j;
    for (i=first,j=0;j<this.getLength();i=(i+1)%maxsize,j++)
        System.out.println(queue[i].id);
}

} [/code]

ArrayDeque 双向队列
LinkedBlockingDeque 阻塞双端队列
ArrayBlockingQueue 双向并发阻塞队列
LinkedBlockingQueue FIFO队列
ConcurrentLinkedQueue 基于链接节点的无界线程安全队列
PriorityBlockingQueue 带优先级的无界阻塞队列
还有很多很多，可以看看AbstractQueue， Deque有哪些实现类。
推荐ArrayBlockingQueue 。并发性能还不错。

队列的实现单纯的是数据结构的问题，既可以用链表结构实现队列，也可以用数组实现。这和语言不是紧密关系，java可以这样实现，C、C++ 也可以。

[quote]
LinkedBlockingQueue 不是 LinkedBlockingDeque
[/quote]
LinkedBlockingDeque 乃阻塞双端队列
LinkedBlockingQueue 乃FIFO阻塞队列
Deque与Queue不懂的话可以看下java api哦亲

更正一个问题：
[code="java"]LinkedBlockingQueue 不是 LinkedBlockingDeque
[/code]

LinkedBlockingDeque 这个队列是存在。
这个是在多线程时采用的双端队列。
full name：java.util.concurrent.LinkedBlockingDeque

数据结构上的东西 ，可以使用栈 ，也可以在堆上，然后封装一些较为方便的操作的接口