Java队列的最佳实现？

我正在（用Java）研究一种递归图像处理算法，该算法从中心点向外递归遍历图像的像素

不幸的是，这会导致堆栈溢出。因此，我决定切换到基于队列的算法

现在，这一切都很好，但考虑到它的队列将在很短的时间内分析数千个像素，同时不断地弹出和推动，而不保持可预测的状态（长度可能在100到20000之间），队列实现需要具有显著的快速弹出和推送功能

链表看起来很吸引人，因为它能够将元素推到自己身上，而无需重新排列列表中的任何其他内容，但为了让它足够快，它需要方便地访问它的头部和尾部（或者如果它没有双重链接，则是倒数第二个节点）。遗憾的是，我找不到任何与Java中链表的底层实现相关的信息，所以很难说链表是否真的是一种方法

这就引出了我的问题。对于我打算做的事情，Java中队列接口的最佳实现是什么？（我不希望编辑甚至访问队列的头和尾以外的任何内容--我不希望进行任何形式的重新排列或任何事情。另一方面，我确实打算进行大量的推送和弹出操作，队列的大小将发生很大的变化，因此预分配将是低效的）

似乎是一种可行的方法，LinkedList是一个双链接列表，适用于队列数据结构（FIFO）

它维护对Head和Tail元素的引用，您可以分别通过

.getFirst（）

和

.getLast（）

获得这些元素

---

您还可以使用

.add（E）

将元素附加到队列的末尾，并使用

.remove（）

退出队列并检索队列的头（第一个元素）

如果您知道队列中项目可能数量的上限，则循环缓冲区比LinkedList快，因为LinkedList为队列中的每个项目创建一个对象（链接）。

请查看提供两端插入/删除的界面。LinkedList实现了该接口（如上所述），但对于您的使用，ArrayQue可能更好——您不会为每个节点分配恒定的对象。再说一遍，使用哪种实现可能并不重要

---

正常的多义性优势开始发挥作用：针对Deque接口而不是它的任何具体实现编写代码的好处在于，您可以非常轻松地切换实现，以测试哪种实现性能最好。只要用

new

更改行，其余代码保持不变。

我认为您可以通过类似于简单的实现来修改一些代码

package DataStructures;

public class Queue<T> {

   private Node<T> root;

   public Queue(T value) {
      root = new Node<T>(value);
   }

   public void enque(T value) {
      Node<T> node = new Node<T>(value);
      node.setNext(root);
      root = node;
   }

   public Node<T> deque() {

      Node<T> node = root;
      Node<T> previous = null;

      while(node.next() != null) {
         previous = node;
         node = node.next();
      }
      node = previous.next();
      previous.setNext(null);
      return node;
   }

   static class Node<T> {

      private T value;
      private Node<T> next;

      public Node (T value) {
         this.value = value;
      }

      public void setValue(T value) {
         this.value = value;
      }

      public T getValue() {
         return value;
      }

      public void setNext(Node<T> next) {
         this.next = next;
      }

      public Node<T> next() {
         return next;
      }
   }
}

包数据结构；
公共类队列{
私有节点根；
公共队列（T值）{
根=新节点（值）；
}
公共空隙率（T值）{
节点=新节点（值）；
node.setNext（根）；
根=节点；
}
公共节点deque（）{
节点=根；
Node-previous=null；
while（node.next（）！=null）{
上一个=节点；
node=node.next（）；
}
node=previous.next（）；
previous.setNext（null）；
返回节点；
}
静态类节点{
私人T值；
私有节点下一步；
公共节点（T值）{
这个值=值；
}
公共无效设置值（T值）{
这个值=值；
}
公共T getValue（）{
返回值；
}
公共void setNext（节点next）{
this.next=next；
}
公共节点下一步（）{
下一步返回；
}
}
}

但是，如果您仍然希望使用递归算法，可以将其更改为在JVM中可能已优化的递归算法，以避免堆栈溢出。

如果使用LinkedList，请小心。如果您这样使用它：

LinkedList<String> queue = new LinkedList<String>();

Queue<String> queue = new LinkedList<String>();

---

在Java中实现堆栈和队列时，最好使用ArrayDeque而不是LinkedList。ArrayDeque用作堆栈时可能比堆栈接口快（而堆栈是线程安全的），用作队列时可能比LinkedList快。请查看此链接。

这是使用迭代器和可编辑接口实现的队列

队列大小将随着其变满而增加

队列接口

package com.practice.ds.queue;

import com.practice.ds.queue.exception.QueueException;

public interface QueueInterface<T> {

    public boolean empty();

    public void enqueue(T item);

    public void dequeue() throws QueueException;

    public T front() throws QueueException;

    public void clear();
}

package com.practice.ds.queue;

import java.util.Iterator;

import com.practice.ds.queue.exception.QueueException;

public class Queue<T> implements QueueInterface<T>, Iterable<T> {

    private static final int DEFAULT_CAPACITY = 10;
    private int current = 0;
    private int rear = 0;
    private T[] queueArray = null;
    private int capacity = 0;

    @SuppressWarnings("unchecked")
    public Queue() {
        capacity = DEFAULT_CAPACITY;
        queueArray = (T[]) new Object[DEFAULT_CAPACITY];
        rear = 0;
        current = 0;
    }

    @Override
    public boolean empty() {
        return capacity == current;
    }

    @Override
    public void enqueue(T item) {
        if(full())
            ensureCapacity();
        queueArray[current] = item;
        current++;
    }

    @Override
    public void dequeue() throws QueueException {
        T dequeuedItem = front();
        rear++;
        System.out.println("Dequed Item is " + dequeuedItem);
    }

    @Override
    public T front() throws QueueException {
        return queueArray[rear];
    }

    @Override
    public void clear() {
        for (int i = 0; i < capacity; i++)
            queueArray[i] = null;
        current = 0;
        rear = 0;
    }

    @SuppressWarnings("unchecked")
    private void ensureCapacity() {
        if (rear != 0) {
            copyElements(queueArray);
        } else {
            capacity *= 2;
            T[] tempQueueArray = (T[]) new Object[capacity];
            copyElements(tempQueueArray);
        }
        current -= rear;
        rear = 0;
    }

    private void copyElements(T[] array) {
        for (int i = rear; i < current; i++)
            array[i - rear] = queueArray[i];
        queueArray = array;
    }

    @Override
    public Iterator<T> iterator() {
        return new QueueItearator<T>();
    }

    public boolean full() {
        return current == capacity;
    }

    private class QueueItearator<T> implements Iterator<T> {

        private int index = rear;

        @Override
        public boolean hasNext() {
            return index < current;
        }

        @SuppressWarnings("unchecked")
        @Override
        public T next() {
            return (T) queueArray[index++];
        }
    }

}

队列的实现

package com.practice.ds.queue;

import com.practice.ds.queue.exception.QueueException;

public interface QueueInterface<T> {

    public boolean empty();

    public void enqueue(T item);

    public void dequeue() throws QueueException;

    public T front() throws QueueException;

    public void clear();
}

package com.practice.ds.queue;

import java.util.Iterator;

import com.practice.ds.queue.exception.QueueException;

public class Queue<T> implements QueueInterface<T>, Iterable<T> {

    private static final int DEFAULT_CAPACITY = 10;
    private int current = 0;
    private int rear = 0;
    private T[] queueArray = null;
    private int capacity = 0;

    @SuppressWarnings("unchecked")
    public Queue() {
        capacity = DEFAULT_CAPACITY;
        queueArray = (T[]) new Object[DEFAULT_CAPACITY];
        rear = 0;
        current = 0;
    }

    @Override
    public boolean empty() {
        return capacity == current;
    }

    @Override
    public void enqueue(T item) {
        if(full())
            ensureCapacity();
        queueArray[current] = item;
        current++;
    }

    @Override
    public void dequeue() throws QueueException {
        T dequeuedItem = front();
        rear++;
        System.out.println("Dequed Item is " + dequeuedItem);
    }

    @Override
    public T front() throws QueueException {
        return queueArray[rear];
    }

    @Override
    public void clear() {
        for (int i = 0; i < capacity; i++)
            queueArray[i] = null;
        current = 0;
        rear = 0;
    }

    @SuppressWarnings("unchecked")
    private void ensureCapacity() {
        if (rear != 0) {
            copyElements(queueArray);
        } else {
            capacity *= 2;
            T[] tempQueueArray = (T[]) new Object[capacity];
            copyElements(tempQueueArray);
        }
        current -= rear;
        rear = 0;
    }

    private void copyElements(T[] array) {
        for (int i = rear; i < current; i++)
            array[i - rear] = queueArray[i];
        queueArray = array;
    }

    @Override
    public Iterator<T> iterator() {
        return new QueueItearator<T>();
    }

    public boolean full() {
        return current == capacity;
    }

    private class QueueItearator<T> implements Iterator<T> {

        private int index = rear;

        @Override
        public boolean hasNext() {
            return index < current;
        }

        @SuppressWarnings("unchecked")
        @Override
        public T next() {
            return (T) queueArray[index++];
        }
    }

}

package com.practice.ds.queue；
导入java.util.Iterator；
导入com.practice.ds.queue.exception.QueueException；
公共类队列实现QueueInterface，Iterable{
专用静态最终int默认_容量=10；
专用int电流=0；
私家车后部=0；
私有T[]队列数组=null；
专用int容量=0；
@抑制警告（“未选中”）
公共队列（）{
容量=默认容量；
queueArray=（T[]）新对象[默认容量]；
后部=0；
电流=0；
}
@凌驾
公共布尔空（）{
返回容量==当前容量；
}
@凌驾
公共无效排队（T项）{
if（full（））
保证再产能（）；
queueArray[当前]=项；
电流++；
}
@凌驾
public void dequeue（）引发QueueException{
T dequeuedItem=front（）；
后++；
System.out.println（“被取消的项目是”+dequeuedItem）；
}
@凌驾
public T front（）引发队列异常{
返回队列数组[后]；
}
@凌驾
公共空间清除（）{
对于（int i=0；iclass Queue {

    private Node head;
    private Node end;

    public void enqueue(Integer data){

        Node node = new Node(data);
        if(this.end == null){
            this.head = node;
            this.end = this.head;
        }
        else {
            this.end.setNext(node);
            this.end = node;
        }
    }

    public void dequeue (){

        if (head == end){
            end = null;
        }

        head = this.head.getNext();
    }


    @Override
    public String toString() {
        return head.getData().toString();
    }

    public String deepToString() {

        StringBuilder res = new StringBuilder();
        res.append(head.getData());

        Node cur = head;
        while (null != (cur = cur.getNext())){
            res.append(" ");
            res.append(cur.getData());

        }
        return res.toString();
    }
}

class Node {

    private Node next;
    private Integer data;


    Node(Integer i){
        data = i;
    }

    public Integer getData() {
        return data;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }
}