love_Sophie
love_Sophie
2012-03-20 12:21
浏览 320
已采纳

java中的队列用什么实现?

java中的队列用什么实现?

  • 点赞
  • 写回答
  • 关注问题
  • 收藏
  • 邀请回答

8条回答 默认 最新

  • iteye_16709
    iteye_16709 2012-03-20 18:23
    已采纳

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

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

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

    点赞 评论
  • long13131462101
    long13131462101 2012-03-20 12:27

    [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]

    点赞 评论
  • long13131462101
    long13131462101 2012-03-20 12:28

    [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]

    点赞 评论
  • Aronlulu
    Aronlulu 2012-03-20 12:50

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

    点赞 评论
  • u011606457
    _1_1_7_ 2012-03-20 14:42

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

    点赞 评论
  • Aronlulu
    Aronlulu 2012-03-20 18:33

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

    点赞 评论
  • iteye_16709
    iteye_16709 2012-03-20 18:40

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

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

    点赞 评论
  • wbpxs
    石头哥哥 2014-08-11 18:56

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

    点赞 评论

相关推荐